Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(506)

Side by Side Diff: third_party/protobuf/src/google/protobuf/generated_message_reflection.h

Issue 2600753002: Reverts third_party/protobuf: Update to HEAD (f52e188fe4) (Closed)
Patch Set: Created 3 years, 12 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
1 // Protocol Buffers - Google's data interchange format 1 // Protocol Buffers - Google's data interchange format
2 // Copyright 2008 Google Inc. All rights reserved. 2 // Copyright 2008 Google Inc. All rights reserved.
3 // https://developers.google.com/protocol-buffers/ 3 // https://developers.google.com/protocol-buffers/
4 // 4 //
5 // Redistribution and use in source and binary forms, with or without 5 // Redistribution and use in source and binary forms, with or without
6 // modification, are permitted provided that the following conditions are 6 // modification, are permitted provided that the following conditions are
7 // met: 7 // met:
8 // 8 //
9 // * Redistributions of source code must retain the above copyright 9 // * Redistributions of source code must retain the above copyright
10 // notice, this list of conditions and the following disclaimer. 10 // notice, this list of conditions and the following disclaimer.
(...skipping 27 matching lines...) Expand all
38 #ifndef GOOGLE_PROTOBUF_GENERATED_MESSAGE_REFLECTION_H__ 38 #ifndef GOOGLE_PROTOBUF_GENERATED_MESSAGE_REFLECTION_H__
39 #define GOOGLE_PROTOBUF_GENERATED_MESSAGE_REFLECTION_H__ 39 #define GOOGLE_PROTOBUF_GENERATED_MESSAGE_REFLECTION_H__
40 40
41 #include <string> 41 #include <string>
42 #include <vector> 42 #include <vector>
43 #include <google/protobuf/stubs/casts.h> 43 #include <google/protobuf/stubs/casts.h>
44 #include <google/protobuf/stubs/common.h> 44 #include <google/protobuf/stubs/common.h>
45 // TODO(jasonh): Remove this once the compiler change to directly include this 45 // TODO(jasonh): Remove this once the compiler change to directly include this
46 // is released to components. 46 // is released to components.
47 #include <google/protobuf/generated_enum_reflection.h> 47 #include <google/protobuf/generated_enum_reflection.h>
48 #include <google/protobuf/generated_message_util.h>
49 #include <google/protobuf/message.h> 48 #include <google/protobuf/message.h>
50 #include <google/protobuf/metadata.h> 49 #include <google/protobuf/metadata.h>
51 #include <google/protobuf/unknown_field_set.h> 50 #include <google/protobuf/unknown_field_set.h>
52 51
53 52
54 namespace google { 53 namespace google {
55 namespace upb { 54 namespace upb {
56 namespace google_opensource { 55 namespace google_opensource {
57 class GMR_Handlers; 56 class GMR_Handlers;
58 } // namespace google_opensource 57 } // namespace google_opensource
59 } // namespace upb 58 } // namespace upb
60 59
61 namespace protobuf { 60 namespace protobuf {
62 class DescriptorPool; 61 class DescriptorPool;
63 class MapKey; 62 class MapKey;
64 class MapValueRef; 63 class MapValueRef;
65 } 64 }
66 65
67 namespace protobuf { 66 namespace protobuf {
68 namespace internal { 67 namespace internal {
69 class DefaultEmptyOneof; 68 class DefaultEmptyOneof;
70 69
71 // Defined in this file. 70 // Defined in this file.
72 class GeneratedMessageReflection; 71 class GeneratedMessageReflection;
73 72
74 // Defined in other files. 73 // Defined in other files.
75 class ExtensionSet; // extension_set.h 74 class ExtensionSet; // extension_set.h
76 75
77 // This struct describes the internal layout of the message, hence this is
78 // used to act on the message reflectively.
79 // default_instance: The default instance of the message. This is only
80 // used to obtain pointers to default instances of embedded
81 // messages, which GetMessage() will return if the particular
82 // sub-message has not been initialized yet. (Thus, all
83 // embedded message fields *must* have non-NULL pointers
84 // in the default instance.)
85 // offsets: An array of ints giving the byte offsets.
86 // For each oneof field, the offset is relative to the
87 // default_oneof_instance. These can be computed at compile
88 // time using the
89 // PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET() macro.
90 // For each none oneof field, the offset is related to
91 // the start of the message object. These can be computed
92 // at compile time using the
93 // GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET() macro.
94 // Besides offsets for all fields, this array also contains
95 // offsets for oneof unions. The offset of the i-th oneof
96 // union is offsets[descriptor->field_count() + i].
97 // has_bit_indices: Mapping from field indexes to their index in the has
98 // bit array.
99 // has_bits_offset: Offset in the message of an array of uint32s of size
100 // descriptor->field_count()/32, rounded up. This is a
101 // bitfield where each bit indicates whether or not the
102 // corresponding field of the message has been initialized.
103 // The bit for field index i is obtained by the expression:
104 // has_bits[i / 32] & (1 << (i % 32))
105 // unknown_fields_offset: Offset in the message of the UnknownFieldSet for
106 // the message.
107 // extensions_offset: Offset in the message of the ExtensionSet for the
108 // message, or -1 if the message type has no extension
109 // ranges.
110 // default_oneof_instance: The default instance of the oneofs. It is a
111 // struct holding the default value of all oneof fields
112 // for this message. It is only used to obtain pointers
113 // to default instances of oneof fields, which Get
114 // methods will return if the field is not set.
115 // oneof_case_offset: Offset in the message of an array of uint32s of
116 // size descriptor->oneof_decl_count(). Each uint32
117 // indicates what field is set for each oneof.
118 // object_size: The size of a message object of this type, as measured
119 // by sizeof().
120 // arena_offset: If a message doesn't have a unknown_field_set that stores
121 // the arena, it must have a direct pointer to the arena.
122 struct ReflectionSchema {
123 public:
124 // Size of a google::protobuf::Message object of this type.
125 uint32 GetObjectSize() const { return object_size_; }
126
127 // Offset of a non-oneof field. Getting a field offset is slightly more
128 // efficient when we know statically that it is not a oneof field.
129 uint32 GetFieldOffsetNonOneof(const FieldDescriptor* field) const {
130 GOOGLE_DCHECK(!field->containing_oneof());
131 return offsets_[field->index()];
132 }
133
134 // Offset of any field.
135 uint32 GetFieldOffset(const FieldDescriptor* field) const {
136 if (field->containing_oneof()) {
137 size_t offset = field->containing_type()->field_count() +
138 field->containing_oneof()->index();
139 return offsets_[offset];
140 } else {
141 return GetFieldOffsetNonOneof(field);
142 }
143 }
144
145 uint32 GetOneofCaseOffset(const OneofDescriptor* oneof_descriptor) const {
146 return oneof_case_offset_ + (oneof_descriptor->index() * sizeof(uint32));
147 }
148
149 bool HasHasbits() const { return has_bits_offset_ != -1; }
150
151 // Bit index within the bit array of hasbits. Bit order is low-to-high.
152 uint32 HasBitIndex(const FieldDescriptor* field) const {
153 GOOGLE_DCHECK(HasHasbits());
154 return has_bit_indices_[field->index()];
155 }
156
157 // Byte offset of the hasbits array.
158 uint32 HasBitsOffset() const {
159 GOOGLE_DCHECK(HasHasbits());
160 return has_bits_offset_;
161 }
162
163 // The offset of the InternalMetadataWithArenaOffset member.
164 // For Lite this will actually be an InternalMetadataWithArenaOffsetLite.
165 // The schema doesn't contain enough information to distinguish between
166 // these two cases.
167 uint32 GetMetadataOffset() const {
168 return metadata_offset_;
169 }
170
171 // Whether this message has an ExtensionSet.
172 bool HasExtensionSet() const { return extensions_offset_ != -1; }
173
174 // The offset of the ExtensionSet in this message.
175 uint32 GetExtensionSetOffset() const {
176 GOOGLE_DCHECK(HasExtensionSet());
177 return extensions_offset_;
178 }
179
180 bool IsDefaultInstance(const Message& message) const {
181 return &message == default_instance_;
182 }
183
184 // Returns a pointer to the default value for this field. The size and type
185 // of the underlying data depends on the field's type.
186 const void *GetFieldDefault(const FieldDescriptor* field) const {
187 return field->containing_oneof()
188 ? reinterpret_cast<const uint8*>(default_oneof_instance_) +
189 offsets_[field->index()]
190 : reinterpret_cast<const uint8*>(default_instance_) +
191 offsets_[field->index()];
192 }
193
194 // These members are intended to be private, but we cannot actually make them
195 // private because this prevents us from using aggregate initialization of
196 // them, ie.
197 //
198 // ReflectionSchema schema = {a, b, c, d, e, ...};
199 // private:
200 const Message* default_instance_;
201 const uint32* offsets_;
202 const uint32* has_bit_indices_;
203 int has_bits_offset_;
204 int metadata_offset_;
205 int extensions_offset_;
206 const void* default_oneof_instance_;
207 int oneof_case_offset_;
208 int object_size_;
209 };
210
211 // Structs that the code generator emits directly to describe a message.
212 // These should never used directly except to build a ReflectionSchema
213 // object.
214 //
215 // EXPERIMENTAL: these are changing rapidly, and may completely disappear
216 // or merge with ReflectionSchema.
217 struct DefaultInstanceData {
218 const Message* default_instance;
219 const void* default_oneof_instance;
220 };
221
222 struct MigrationSchema {
223 int32 offsets_index;
224 int32 has_bit_indices_index;
225 int object_size;
226 };
227
228 // THIS CLASS IS NOT INTENDED FOR DIRECT USE. It is intended for use 76 // THIS CLASS IS NOT INTENDED FOR DIRECT USE. It is intended for use
229 // by generated code. This class is just a big hack that reduces code 77 // by generated code. This class is just a big hack that reduces code
230 // size. 78 // size.
231 // 79 //
232 // A GeneratedMessageReflection is an implementation of Reflection 80 // A GeneratedMessageReflection is an implementation of Reflection
233 // which expects all fields to be backed by simple variables located in 81 // which expects all fields to be backed by simple variables located in
234 // memory. The locations are given using a base pointer and a set of 82 // memory. The locations are given using a base pointer and a set of
235 // offsets. 83 // offsets.
236 // 84 //
237 // It is required that the user represents fields of each type in a standard 85 // It is required that the user represents fields of each type in a standard
238 // way, so that GeneratedMessageReflection can cast the void* pointer to 86 // way, so that GeneratedMessageReflection can cast the void* pointer to
239 // the appropriate type. For primitive fields and string fields, each field 87 // the appropriate type. For primitive fields and string fields, each field
240 // should be represented using the obvious C++ primitive type. Enums and 88 // should be represented using the obvious C++ primitive type. Enums and
241 // Messages are different: 89 // Messages are different:
242 // - Singular Message fields are stored as a pointer to a Message. These 90 // - Singular Message fields are stored as a pointer to a Message. These
243 // should start out NULL, except for in the default instance where they 91 // should start out NULL, except for in the default instance where they
244 // should start out pointing to other default instances. 92 // should start out pointing to other default instances.
245 // - Enum fields are stored as an int. This int must always contain 93 // - Enum fields are stored as an int. This int must always contain
246 // a valid value, such that EnumDescriptor::FindValueByNumber() would 94 // a valid value, such that EnumDescriptor::FindValueByNumber() would
247 // not return NULL. 95 // not return NULL.
248 // - Repeated fields are stored as RepeatedFields or RepeatedPtrFields 96 // - Repeated fields are stored as RepeatedFields or RepeatedPtrFields
249 // of whatever type the individual field would be. Strings and 97 // of whatever type the individual field would be. Strings and
250 // Messages use RepeatedPtrFields while everything else uses 98 // Messages use RepeatedPtrFields while everything else uses
251 // RepeatedFields. 99 // RepeatedFields.
252 class LIBPROTOBUF_EXPORT GeneratedMessageReflection PROTOBUF_FINAL : public Refl ection { 100 class LIBPROTOBUF_EXPORT GeneratedMessageReflection : public Reflection {
253 public: 101 public:
254 // Constructs a GeneratedMessageReflection. 102 // Constructs a GeneratedMessageReflection.
255 // Parameters: 103 // Parameters:
256 // descriptor: The descriptor for the message type being implemented. 104 // descriptor: The descriptor for the message type being implemented.
257 // schema: The description of the internal guts of the message. 105 // default_instance: The default instance of the message. This is only
106 // used to obtain pointers to default instances of embedded
107 // messages, which GetMessage() will return if the particular
108 // sub-message has not been initialized yet. (Thus, all
109 // embedded message fields *must* have non-NULL pointers
110 // in the default instance.)
111 // offsets: An array of ints giving the byte offsets, relative to
112 // the start of the message object, of each field. These can
113 // be computed at compile time using the
114 // GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET() macro, de fined
115 // below.
116 // has_bits_offset: Offset in the message of an array of uint32s of size
117 // descriptor->field_count()/32, rounded up. This is a
118 // bitfield where each bit indicates whether or not the
119 // corresponding field of the message has been initialized.
120 // The bit for field index i is obtained by the expression:
121 // has_bits[i / 32] & (1 << (i % 32))
122 // unknown_fields_offset: Offset in the message of the UnknownFieldSet for
123 // the message.
124 // extensions_offset: Offset in the message of the ExtensionSet for the
125 // message, or -1 if the message type has no extension
126 // ranges.
258 // pool: DescriptorPool to search for extension definitions. Only 127 // pool: DescriptorPool to search for extension definitions. Only
259 // used by FindKnownExtensionByName() and 128 // used by FindKnownExtensionByName() and
260 // FindKnownExtensionByNumber(). 129 // FindKnownExtensionByNumber().
261 // factory: MessageFactory to use to construct extension messages. 130 // factory: MessageFactory to use to construct extension messages.
131 // object_size: The size of a message object of this type, as measured
132 // by sizeof().
262 GeneratedMessageReflection(const Descriptor* descriptor, 133 GeneratedMessageReflection(const Descriptor* descriptor,
263 const ReflectionSchema& schema, 134 const Message* default_instance,
135 const int offsets[],
136 int has_bits_offset,
137 int unknown_fields_offset,
138 int extensions_offset,
264 const DescriptorPool* pool, 139 const DescriptorPool* pool,
265 MessageFactory* factory); 140 MessageFactory* factory,
141 int object_size,
142 int arena_offset,
143 int is_default_instance_offset = -1);
266 144
145 // Similar with the construction above. Call this construction if the
146 // message has oneof definition.
147 // Parameters:
148 // offsets: An array of ints giving the byte offsets.
149 // For each oneof field, the offset is relative to the
150 // default_oneof_instance. These can be computed at compile
151 // time using the
152 // PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET() macro.
153 // For each none oneof field, the offset is related to
154 // the start of the message object. These can be computed
155 // at compile time using the
156 // GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET() macro.
157 // Besides offsets for all fields, this array also contains
158 // offsets for oneof unions. The offset of the i-th oneof
159 // union is offsets[descriptor->field_count() + i].
160 // default_oneof_instance: The default instance of the oneofs. It is a
161 // struct holding the default value of all oneof fields
162 // for this message. It is only used to obtain pointers
163 // to default instances of oneof fields, which Get
164 // methods will return if the field is not set.
165 // oneof_case_offset: Offset in the message of an array of uint32s of
166 // size descriptor->oneof_decl_count(). Each uint32
167 // indicates what field is set for each oneof.
168 // other parameters are the same with the construction above.
169 GeneratedMessageReflection(const Descriptor* descriptor,
170 const Message* default_instance,
171 const int offsets[],
172 int has_bits_offset,
173 int unknown_fields_offset,
174 int extensions_offset,
175 const void* default_oneof_instance,
176 int oneof_case_offset,
177 const DescriptorPool* pool,
178 MessageFactory* factory,
179 int object_size,
180 int arena_offset,
181 int is_default_instance_offset = -1);
267 ~GeneratedMessageReflection(); 182 ~GeneratedMessageReflection();
268 183
184 // Shorter-to-call helpers for the above two constructions that work if the
185 // pool and factory are the usual, namely, DescriptorPool::generated_pool()
186 // and MessageFactory::generated_factory().
187
188 static GeneratedMessageReflection* NewGeneratedMessageReflection(
189 const Descriptor* descriptor,
190 const Message* default_instance,
191 const int offsets[],
192 int has_bits_offset,
193 int unknown_fields_offset,
194 int extensions_offset,
195 const void* default_oneof_instance,
196 int oneof_case_offset,
197 int object_size,
198 int arena_offset,
199 int is_default_instance_offset = -1);
200
201 static GeneratedMessageReflection* NewGeneratedMessageReflection(
202 const Descriptor* descriptor,
203 const Message* default_instance,
204 const int offsets[],
205 int has_bits_offset,
206 int unknown_fields_offset,
207 int extensions_offset,
208 int object_size,
209 int arena_offset,
210 int is_default_instance_offset = -1);
211
269 // implements Reflection ------------------------------------------- 212 // implements Reflection -------------------------------------------
270 213
271 const UnknownFieldSet& GetUnknownFields(const Message& message) const; 214 const UnknownFieldSet& GetUnknownFields(const Message& message) const;
272 UnknownFieldSet* MutableUnknownFields(Message* message) const; 215 UnknownFieldSet* MutableUnknownFields(Message* message) const;
273 216
274 int SpaceUsed(const Message& message) const; 217 int SpaceUsed(const Message& message) const;
275 218
276 bool HasField(const Message& message, const FieldDescriptor* field) const; 219 bool HasField(const Message& message, const FieldDescriptor* field) const;
277 int FieldSize(const Message& message, const FieldDescriptor* field) const; 220 int FieldSize(const Message& message, const FieldDescriptor* field) const;
278 void ClearField(Message* message, const FieldDescriptor* field) const; 221 void ClearField(Message* message, const FieldDescriptor* field) const;
279 bool HasOneof(const Message& message, 222 bool HasOneof(const Message& message,
280 const OneofDescriptor* oneof_descriptor) const; 223 const OneofDescriptor* oneof_descriptor) const;
281 void ClearOneof(Message* message, const OneofDescriptor* field) const; 224 void ClearOneof(Message* message, const OneofDescriptor* field) const;
282 void RemoveLast(Message* message, const FieldDescriptor* field) const; 225 void RemoveLast(Message* message, const FieldDescriptor* field) const;
283 Message* ReleaseLast(Message* message, const FieldDescriptor* field) const; 226 Message* ReleaseLast(Message* message, const FieldDescriptor* field) const;
284 void Swap(Message* message1, Message* message2) const; 227 void Swap(Message* message1, Message* message2) const;
285 void SwapFields(Message* message1, Message* message2, 228 void SwapFields(Message* message1, Message* message2,
286 const std::vector<const FieldDescriptor*>& fields) const; 229 const vector<const FieldDescriptor*>& fields) const;
287 void SwapElements(Message* message, const FieldDescriptor* field, 230 void SwapElements(Message* message, const FieldDescriptor* field,
288 int index1, int index2) const; 231 int index1, int index2) const;
289 void ListFields(const Message& message, 232 void ListFields(const Message& message,
290 std::vector<const FieldDescriptor*>* output) const; 233 vector<const FieldDescriptor*>* output) const;
291 234
292 int32 GetInt32 (const Message& message, 235 int32 GetInt32 (const Message& message,
293 const FieldDescriptor* field) const; 236 const FieldDescriptor* field) const;
294 int64 GetInt64 (const Message& message, 237 int64 GetInt64 (const Message& message,
295 const FieldDescriptor* field) const; 238 const FieldDescriptor* field) const;
296 uint32 GetUInt32(const Message& message, 239 uint32 GetUInt32(const Message& message,
297 const FieldDescriptor* field) const; 240 const FieldDescriptor* field) const;
298 uint64 GetUInt64(const Message& message, 241 uint64 GetUInt64(const Message& message,
299 const FieldDescriptor* field) const; 242 const FieldDescriptor* field) const;
300 float GetFloat (const Message& message, 243 float GetFloat (const Message& message,
(...skipping 182 matching lines...) Expand 10 before | Expand all | Expand 10 after
483 426
484 virtual MessageFactory* GetMessageFactory() const; 427 virtual MessageFactory* GetMessageFactory() const;
485 428
486 virtual void* RepeatedFieldData( 429 virtual void* RepeatedFieldData(
487 Message* message, const FieldDescriptor* field, 430 Message* message, const FieldDescriptor* field,
488 FieldDescriptor::CppType cpp_type, 431 FieldDescriptor::CppType cpp_type,
489 const Descriptor* message_type) const; 432 const Descriptor* message_type) const;
490 433
491 private: 434 private:
492 friend class GeneratedMessage; 435 friend class GeneratedMessage;
493 friend class upb::google_opensource::GMR_Handlers;
494
495 const Descriptor* const descriptor_;
496 const ReflectionSchema schema_;
497 const DescriptorPool* const descriptor_pool_;
498 MessageFactory* const message_factory_;
499 436
500 // To parse directly into a proto2 generated class, the class GMR_Handlers 437 // To parse directly into a proto2 generated class, the class GMR_Handlers
501 // needs access to member offsets and hasbits. 438 // needs access to member offsets and hasbits.
502 // upb still needs these. 439 friend class upb::google_opensource::GMR_Handlers;
503 // TODO(haberman) clean this up.
504 const Message* const default_instance_;
505 const void* const default_oneof_instance_;
506 const uint32* const offsets_;
507 const uint32* const has_bits_indices_;
508 const int has_bits_offset_;
509 const int oneof_case_offset_;
510 const int unknown_fields_offset_;
511 const int extensions_offset_;
512 const int arena_offset_;
513 const int object_size_;
514 440
515 template <class T> 441 const Descriptor* descriptor_;
516 const T& GetRawNonOneof(const Message& message, 442 const Message* default_instance_;
517 const FieldDescriptor* field) const; 443 const void* default_oneof_instance_;
518 template <class T> 444 const int* offsets_;
519 T* MutableRawNonOneof(Message* message, const FieldDescriptor* field) const; 445
446 int has_bits_offset_;
447 int oneof_case_offset_;
448 int unknown_fields_offset_;
449 int extensions_offset_;
450 int arena_offset_;
451 int is_default_instance_offset_;
452 int object_size_;
453
454 static const int kHasNoDefaultInstanceField = -1;
455
456 const DescriptorPool* descriptor_pool_;
457 MessageFactory* message_factory_;
520 458
521 template <typename Type> 459 template <typename Type>
522 const Type& GetRaw(const Message& message, 460 inline const Type& GetRaw(const Message& message,
523 const FieldDescriptor* field) const; 461 const FieldDescriptor* field) const;
524 template <typename Type> 462 template <typename Type>
525 inline Type* MutableRaw(Message* message, 463 inline Type* MutableRaw(Message* message,
526 const FieldDescriptor* field) const; 464 const FieldDescriptor* field) const;
527 template <typename Type> 465 template <typename Type>
528 inline const Type& DefaultRaw(const FieldDescriptor* field) const; 466 inline const Type& DefaultRaw(const FieldDescriptor* field) const;
467 template <typename Type>
468 inline const Type& DefaultOneofRaw(const FieldDescriptor* field) const;
529 469
530 inline const uint32* GetHasBits(const Message& message) const; 470 inline const uint32* GetHasBits(const Message& message) const;
531 inline uint32* MutableHasBits(Message* message) const; 471 inline uint32* MutableHasBits(Message* message) const;
532 inline uint32 GetOneofCase( 472 inline uint32 GetOneofCase(
533 const Message& message, 473 const Message& message,
534 const OneofDescriptor* oneof_descriptor) const; 474 const OneofDescriptor* oneof_descriptor) const;
535 inline uint32* MutableOneofCase( 475 inline uint32* MutableOneofCase(
536 Message* message, 476 Message* message,
537 const OneofDescriptor* oneof_descriptor) const; 477 const OneofDescriptor* oneof_descriptor) const;
538 inline const ExtensionSet& GetExtensionSet(const Message& message) const; 478 inline const ExtensionSet& GetExtensionSet(const Message& message) const;
539 inline ExtensionSet* MutableExtensionSet(Message* message) const; 479 inline ExtensionSet* MutableExtensionSet(Message* message) const;
540 inline Arena* GetArena(Message* message) const; 480 inline Arena* GetArena(Message* message) const;
481 inline const internal::InternalMetadataWithArena&
482 GetInternalMetadataWithArena(const Message& message) const;
483 inline internal::InternalMetadataWithArena*
484 MutableInternalMetadataWithArena(Message* message) const;
541 485
542 inline const InternalMetadataWithArena& GetInternalMetadataWithArena( 486 inline bool GetIsDefaultInstance(const Message& message) const;
543 const Message& message) const;
544
545 inline InternalMetadataWithArena*
546 MutableInternalMetadataWithArena(Message* message) const;
547 487
548 inline bool HasBit(const Message& message, 488 inline bool HasBit(const Message& message,
549 const FieldDescriptor* field) const; 489 const FieldDescriptor* field) const;
550 inline void SetBit(Message* message, 490 inline void SetBit(Message* message,
551 const FieldDescriptor* field) const; 491 const FieldDescriptor* field) const;
552 inline void ClearBit(Message* message, 492 inline void ClearBit(Message* message,
553 const FieldDescriptor* field) const; 493 const FieldDescriptor* field) const;
554 inline void SwapBit(Message* message1, 494 inline void SwapBit(Message* message1,
555 Message* message2, 495 Message* message2,
556 const FieldDescriptor* field) const; 496 const FieldDescriptor* field) const;
(...skipping 67 matching lines...) Expand 10 before | Expand all | Expand 10 after
624 const FieldDescriptor* field, 564 const FieldDescriptor* field,
625 MessageFactory* factory = NULL) const; 565 MessageFactory* factory = NULL) const;
626 566
627 void UnsafeArenaSetAllocatedMessage(Message* message, 567 void UnsafeArenaSetAllocatedMessage(Message* message,
628 Message* sub_message, 568 Message* sub_message,
629 const FieldDescriptor* field) const; 569 const FieldDescriptor* field) const;
630 570
631 internal::MapFieldBase* MapData( 571 internal::MapFieldBase* MapData(
632 Message* message, const FieldDescriptor* field) const; 572 Message* message, const FieldDescriptor* field) const;
633 573
634 friend inline // inline so nobody can call this function.
635 void
636 RegisterAllTypesInternal(const Metadata* file_level_metadata, int size);
637 GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(GeneratedMessageReflection); 574 GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(GeneratedMessageReflection);
638 }; 575 };
639 576
640 // Returns the offset of the given field within the given aggregate type. 577 // Returns the offset of the given field within the given aggregate type.
641 // This is equivalent to the ANSI C offsetof() macro. However, according 578 // This is equivalent to the ANSI C offsetof() macro. However, according
642 // to the C++ standard, offsetof() only works on POD types, and GCC 579 // to the C++ standard, offsetof() only works on POD types, and GCC
643 // enforces this requirement with a warning. In practice, this rule is 580 // enforces this requirement with a warning. In practice, this rule is
644 // unnecessarily strict; there is probably no compiler or platform on 581 // unnecessarily strict; there is probably no compiler or platform on
645 // which the offsets of the direct fields of a class are non-constant. 582 // which the offsets of the direct fields of a class are non-constant.
646 // Fields inherited from superclasses *can* have non-constant offsets, 583 // Fields inherited from superclasses *can* have non-constant offsets,
647 // but that's not what this macro will be used for. 584 // but that's not what this macro will be used for.
648 #if defined(__clang__) 585 #if defined(__clang__)
649 // For Clang we use __builtin_offsetof() and suppress the warning, 586 // For Clang we use __builtin_offsetof() and suppress the warning,
650 // to avoid Control Flow Integrity and UBSan vptr sanitizers from 587 // to avoid Control Flow Integrity and UBSan vptr sanitizers from
651 // crashing while trying to validate the invalid reinterpet_casts. 588 // crashing while trying to validate the invalid reinterpet_casts.
652 #define GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TYPE, FIELD) \ 589 #define GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TYPE, FIELD) \
653 _Pragma("clang diagnostic push") \ 590 _Pragma("clang diagnostic push") \
654 _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \ 591 _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \
655 __builtin_offsetof(TYPE, FIELD) \ 592 __builtin_offsetof(TYPE, FIELD) \
656 _Pragma("clang diagnostic pop") 593 _Pragma("clang diagnostic pop")
657 #else 594 #else
658 // Note that we calculate relative to the pointer value 16 here since if we 595 // Note that we calculate relative to the pointer value 16 here since if we
659 // just use zero, GCC complains about dereferencing a NULL pointer. We 596 // just use zero, GCC complains about dereferencing a NULL pointer. We
660 // choose 16 rather than some other number just in case the compiler would 597 // choose 16 rather than some other number just in case the compiler would
661 // be confused by an unaligned pointer. 598 // be confused by an unaligned pointer.
662 #define GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TYPE, FIELD) \ 599 #define GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TYPE, FIELD) \
663 static_cast< ::google::protobuf::uint32>( \ 600 static_cast<int>( \
664 reinterpret_cast<const char*>( \ 601 reinterpret_cast<const char*>( \
665 &reinterpret_cast<const TYPE*>(16)->FIELD) - \ 602 &reinterpret_cast<const TYPE*>(16)->FIELD) - \
666 reinterpret_cast<const char*>(16)) 603 reinterpret_cast<const char*>(16))
667 #endif 604 #endif
668 605
669 #define PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(ONEOF, FIELD) \ 606 #define PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(ONEOF, FIELD) \
670 static_cast< ::google::protobuf::uint32>( \ 607 static_cast<int>( \
671 reinterpret_cast<const char*>(&(ONEOF->FIELD)) \ 608 reinterpret_cast<const char*>(&(ONEOF->FIELD)) \
672 - reinterpret_cast<const char*>(ONEOF)) 609 - reinterpret_cast<const char*>(ONEOF))
673 610
674 // There are some places in proto2 where dynamic_cast would be useful as an 611 // There are some places in proto2 where dynamic_cast would be useful as an
675 // optimization. For example, take Message::MergeFrom(const Message& other). 612 // optimization. For example, take Message::MergeFrom(const Message& other).
676 // For a given generated message FooMessage, we generate these two methods: 613 // For a given generated message FooMessage, we generate these two methods:
677 // void MergeFrom(const FooMessage& other); 614 // void MergeFrom(const FooMessage& other);
678 // void MergeFrom(const Message& other); 615 // void MergeFrom(const Message& other);
679 // The former method can be implemented directly in terms of FooMessage's 616 // The former method can be implemented directly in terms of FooMessage's
680 // inline accessors, but the latter method must work with the reflection 617 // inline accessors, but the latter method must work with the reflection
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after
732 return dynamic_cast<T*>(from); 669 return dynamic_cast<T*>(from);
733 #endif 670 #endif
734 } 671 }
735 672
736 template <typename T> 673 template <typename T>
737 T* DynamicCastToGenerated(Message* from) { 674 T* DynamicCastToGenerated(Message* from) {
738 const Message* message_const = from; 675 const Message* message_const = from;
739 return const_cast<T*>(DynamicCastToGenerated<const T>(message_const)); 676 return const_cast<T*>(DynamicCastToGenerated<const T>(message_const));
740 } 677 }
741 678
742 LIBPROTOBUF_EXPORT void AssignDescriptors(
743 const string& filename, const MigrationSchema* schemas,
744 const DefaultInstanceData* default_instance_data, const uint32* offsets,
745 MessageFactory* factory,
746 // update the following descriptor arrays.
747 Metadata* file_level_metadata,
748 const EnumDescriptor** file_level_enum_descriptors,
749 const ServiceDescriptor** file_level_service_descriptors);
750
751 LIBPROTOBUF_EXPORT void AssignDescriptors(
752 const string& filename, const ReflectionSchema* schemas,
753 MessageFactory* factory,
754 // update the following descriptor arrays.
755 Metadata* file_level_metadata,
756 const EnumDescriptor** file_level_enum_descriptors,
757 const ServiceDescriptor** file_level_service_descriptors);
758
759 LIBPROTOBUF_EXPORT void RegisterAllTypes(const Metadata* file_level_metadata, in t size);
760
761 } // namespace internal 679 } // namespace internal
762 } // namespace protobuf 680 } // namespace protobuf
763 681
764 } // namespace google 682 } // namespace google
765 #endif // GOOGLE_PROTOBUF_GENERATED_MESSAGE_REFLECTION_H__ 683 #endif // GOOGLE_PROTOBUF_GENERATED_MESSAGE_REFLECTION_H__
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698