Line data Source code
1 : // Protocol Buffers - Google's data interchange format
2 : // Copyright 2008 Google Inc. All rights reserved.
3 : // https://developers.google.com/protocol-buffers/
4 : //
5 : // Redistribution and use in source and binary forms, with or without
6 : // modification, are permitted provided that the following conditions are
7 : // met:
8 : //
9 : // * Redistributions of source code must retain the above copyright
10 : // notice, this list of conditions and the following disclaimer.
11 : // * Redistributions in binary form must reproduce the above
12 : // copyright notice, this list of conditions and the following disclaimer
13 : // in the documentation and/or other materials provided with the
14 : // distribution.
15 : // * Neither the name of Google Inc. nor the names of its
16 : // contributors may be used to endorse or promote products derived from
17 : // this software without specific prior written permission.
18 : //
19 : // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20 : // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21 : // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22 : // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23 : // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 : // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25 : // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26 : // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27 : // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 : // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29 : // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 :
31 : // Author: kenton@google.com (Kenton Varda)
32 : // Based on original Protocol Buffers design by
33 : // Sanjay Ghemawat, Jeff Dean, and others.
34 :
35 : #include <google/protobuf/stubs/hash.h>
36 : #include <google/protobuf/stubs/common.h>
37 : #include <google/protobuf/stubs/once.h>
38 : #include <google/protobuf/extension_set.h>
39 : #include <google/protobuf/message_lite.h>
40 : #include <google/protobuf/io/coded_stream.h>
41 : #include <google/protobuf/wire_format_lite_inl.h>
42 : #include <google/protobuf/repeated_field.h>
43 : #include <google/protobuf/stubs/map_util.h>
44 :
45 : namespace google {
46 : namespace protobuf {
47 : namespace internal {
48 :
49 : namespace {
50 :
51 0 : inline WireFormatLite::FieldType real_type(FieldType type) {
52 0 : GOOGLE_DCHECK(type > 0 && type <= WireFormatLite::MAX_FIELD_TYPE);
53 0 : return static_cast<WireFormatLite::FieldType>(type);
54 : }
55 :
56 0 : inline WireFormatLite::CppType cpp_type(FieldType type) {
57 0 : return WireFormatLite::FieldTypeToCppType(real_type(type));
58 : }
59 :
60 0 : inline bool is_packable(WireFormatLite::WireType type) {
61 0 : switch (type) {
62 : case WireFormatLite::WIRETYPE_VARINT:
63 : case WireFormatLite::WIRETYPE_FIXED64:
64 : case WireFormatLite::WIRETYPE_FIXED32:
65 0 : return true;
66 : case WireFormatLite::WIRETYPE_LENGTH_DELIMITED:
67 : case WireFormatLite::WIRETYPE_START_GROUP:
68 : case WireFormatLite::WIRETYPE_END_GROUP:
69 0 : return false;
70 :
71 : // Do not add a default statement. Let the compiler complain when someone
72 : // adds a new wire type.
73 : }
74 0 : }
75 :
76 : // Registry stuff.
77 : typedef hash_map<pair<const MessageLite*, int>,
78 : ExtensionInfo> ExtensionRegistry;
79 : ExtensionRegistry* registry_ = NULL;
80 : GOOGLE_PROTOBUF_DECLARE_ONCE(registry_init_);
81 :
82 0 : void DeleteRegistry() {
83 0 : delete registry_;
84 0 : registry_ = NULL;
85 0 : }
86 :
87 0 : void InitRegistry() {
88 0 : registry_ = new ExtensionRegistry;
89 0 : OnShutdown(&DeleteRegistry);
90 0 : }
91 :
92 : // This function is only called at startup, so there is no need for thread-
93 : // safety.
94 0 : void Register(const MessageLite* containing_type,
95 : int number, ExtensionInfo info) {
96 0 : ::google::protobuf::GoogleOnceInit(®istry_init_, &InitRegistry);
97 :
98 0 : if (!InsertIfNotPresent(registry_, make_pair(containing_type, number),
99 : info)) {
100 0 : GOOGLE_LOG(FATAL) << "Multiple extension registrations for type \""
101 0 : << containing_type->GetTypeName()
102 0 : << "\", field number " << number << ".";
103 : }
104 0 : }
105 :
106 0 : const ExtensionInfo* FindRegisteredExtension(
107 : const MessageLite* containing_type, int number) {
108 0 : return (registry_ == NULL) ? NULL :
109 0 : FindOrNull(*registry_, make_pair(containing_type, number));
110 : }
111 :
112 : } // namespace
113 :
114 0 : ExtensionFinder::~ExtensionFinder() {}
115 :
116 0 : bool GeneratedExtensionFinder::Find(int number, ExtensionInfo* output) {
117 : const ExtensionInfo* extension =
118 0 : FindRegisteredExtension(containing_type_, number);
119 0 : if (extension == NULL) {
120 0 : return false;
121 : } else {
122 0 : *output = *extension;
123 0 : return true;
124 : }
125 : }
126 :
127 0 : void ExtensionSet::RegisterExtension(const MessageLite* containing_type,
128 : int number, FieldType type,
129 : bool is_repeated, bool is_packed) {
130 0 : GOOGLE_CHECK_NE(type, WireFormatLite::TYPE_ENUM);
131 0 : GOOGLE_CHECK_NE(type, WireFormatLite::TYPE_MESSAGE);
132 0 : GOOGLE_CHECK_NE(type, WireFormatLite::TYPE_GROUP);
133 0 : ExtensionInfo info(type, is_repeated, is_packed);
134 0 : Register(containing_type, number, info);
135 0 : }
136 :
137 0 : static bool CallNoArgValidityFunc(const void* arg, int number) {
138 : // Note: Must use C-style cast here rather than reinterpret_cast because
139 : // the C++ standard at one point did not allow casts between function and
140 : // data pointers and some compilers enforce this for C++-style casts. No
141 : // compiler enforces it for C-style casts since lots of C-style code has
142 : // relied on these kinds of casts for a long time, despite being
143 : // technically undefined. See:
144 : // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#195
145 : // Also note: Some compilers do not allow function pointers to be "const".
146 : // Which makes sense, I suppose, because it's meaningless.
147 0 : return ((EnumValidityFunc*)arg)(number);
148 : }
149 :
150 0 : void ExtensionSet::RegisterEnumExtension(const MessageLite* containing_type,
151 : int number, FieldType type,
152 : bool is_repeated, bool is_packed,
153 : EnumValidityFunc* is_valid) {
154 0 : GOOGLE_CHECK_EQ(type, WireFormatLite::TYPE_ENUM);
155 0 : ExtensionInfo info(type, is_repeated, is_packed);
156 0 : info.enum_validity_check.func = CallNoArgValidityFunc;
157 : // See comment in CallNoArgValidityFunc() about why we use a c-style cast.
158 0 : info.enum_validity_check.arg = (void*)is_valid;
159 0 : Register(containing_type, number, info);
160 0 : }
161 :
162 0 : void ExtensionSet::RegisterMessageExtension(const MessageLite* containing_type,
163 : int number, FieldType type,
164 : bool is_repeated, bool is_packed,
165 : const MessageLite* prototype) {
166 0 : GOOGLE_CHECK(type == WireFormatLite::TYPE_MESSAGE ||
167 0 : type == WireFormatLite::TYPE_GROUP);
168 0 : ExtensionInfo info(type, is_repeated, is_packed);
169 0 : info.message_prototype = prototype;
170 0 : Register(containing_type, number, info);
171 0 : }
172 :
173 :
174 : // ===================================================================
175 : // Constructors and basic methods.
176 :
177 30 : ExtensionSet::ExtensionSet() {}
178 :
179 18 : ExtensionSet::~ExtensionSet() {
180 27 : for (map<int, Extension>::iterator iter = extensions_.begin();
181 18 : iter != extensions_.end(); ++iter) {
182 0 : iter->second.Free();
183 : }
184 9 : }
185 :
186 : // Defined in extension_set_heavy.cc.
187 : // void ExtensionSet::AppendToList(const Descriptor* containing_type,
188 : // const DescriptorPool* pool,
189 : // vector<const FieldDescriptor*>* output) const
190 :
191 0 : bool ExtensionSet::Has(int number) const {
192 0 : map<int, Extension>::const_iterator iter = extensions_.find(number);
193 0 : if (iter == extensions_.end()) return false;
194 0 : GOOGLE_DCHECK(!iter->second.is_repeated);
195 0 : return !iter->second.is_cleared;
196 : }
197 :
198 0 : int ExtensionSet::NumExtensions() const {
199 0 : int result = 0;
200 0 : for (map<int, Extension>::const_iterator iter = extensions_.begin();
201 0 : iter != extensions_.end(); ++iter) {
202 0 : if (!iter->second.is_cleared) {
203 0 : ++result;
204 : }
205 : }
206 0 : return result;
207 : }
208 :
209 0 : int ExtensionSet::ExtensionSize(int number) const {
210 0 : map<int, Extension>::const_iterator iter = extensions_.find(number);
211 0 : if (iter == extensions_.end()) return false;
212 0 : return iter->second.GetSize();
213 : }
214 :
215 0 : FieldType ExtensionSet::ExtensionType(int number) const {
216 0 : map<int, Extension>::const_iterator iter = extensions_.find(number);
217 0 : if (iter == extensions_.end()) {
218 0 : GOOGLE_LOG(DFATAL) << "Don't lookup extension types if they aren't present (1). ";
219 0 : return 0;
220 : }
221 0 : if (iter->second.is_cleared) {
222 0 : GOOGLE_LOG(DFATAL) << "Don't lookup extension types if they aren't present (2). ";
223 : }
224 0 : return iter->second.type;
225 : }
226 :
227 0 : void ExtensionSet::ClearExtension(int number) {
228 0 : map<int, Extension>::iterator iter = extensions_.find(number);
229 0 : if (iter == extensions_.end()) return;
230 0 : iter->second.Clear();
231 : }
232 :
233 : // ===================================================================
234 : // Field accessors
235 :
236 : namespace {
237 :
238 : enum Cardinality {
239 : REPEATED,
240 : OPTIONAL
241 : };
242 :
243 : } // namespace
244 :
245 : #define GOOGLE_DCHECK_TYPE(EXTENSION, LABEL, CPPTYPE) \
246 : GOOGLE_DCHECK_EQ((EXTENSION).is_repeated ? REPEATED : OPTIONAL, LABEL); \
247 : GOOGLE_DCHECK_EQ(cpp_type((EXTENSION).type), WireFormatLite::CPPTYPE_##CPPTYPE)
248 :
249 : // -------------------------------------------------------------------
250 : // Primitives
251 :
252 : #define PRIMITIVE_ACCESSORS(UPPERCASE, LOWERCASE, CAMELCASE) \
253 : \
254 : LOWERCASE ExtensionSet::Get##CAMELCASE(int number, \
255 : LOWERCASE default_value) const { \
256 : map<int, Extension>::const_iterator iter = extensions_.find(number); \
257 : if (iter == extensions_.end() || iter->second.is_cleared) { \
258 : return default_value; \
259 : } else { \
260 : GOOGLE_DCHECK_TYPE(iter->second, OPTIONAL, UPPERCASE); \
261 : return iter->second.LOWERCASE##_value; \
262 : } \
263 : } \
264 : \
265 : void ExtensionSet::Set##CAMELCASE(int number, FieldType type, \
266 : LOWERCASE value, \
267 : const FieldDescriptor* descriptor) { \
268 : Extension* extension; \
269 : if (MaybeNewExtension(number, descriptor, &extension)) { \
270 : extension->type = type; \
271 : GOOGLE_DCHECK_EQ(cpp_type(extension->type), WireFormatLite::CPPTYPE_##UPPERCASE); \
272 : extension->is_repeated = false; \
273 : } else { \
274 : GOOGLE_DCHECK_TYPE(*extension, OPTIONAL, UPPERCASE); \
275 : } \
276 : extension->is_cleared = false; \
277 : extension->LOWERCASE##_value = value; \
278 : } \
279 : \
280 : LOWERCASE ExtensionSet::GetRepeated##CAMELCASE(int number, int index) const { \
281 : map<int, Extension>::const_iterator iter = extensions_.find(number); \
282 : GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empty)."; \
283 : GOOGLE_DCHECK_TYPE(iter->second, REPEATED, UPPERCASE); \
284 : return iter->second.repeated_##LOWERCASE##_value->Get(index); \
285 : } \
286 : \
287 : void ExtensionSet::SetRepeated##CAMELCASE( \
288 : int number, int index, LOWERCASE value) { \
289 : map<int, Extension>::iterator iter = extensions_.find(number); \
290 : GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empty)."; \
291 : GOOGLE_DCHECK_TYPE(iter->second, REPEATED, UPPERCASE); \
292 : iter->second.repeated_##LOWERCASE##_value->Set(index, value); \
293 : } \
294 : \
295 : void ExtensionSet::Add##CAMELCASE(int number, FieldType type, \
296 : bool packed, LOWERCASE value, \
297 : const FieldDescriptor* descriptor) { \
298 : Extension* extension; \
299 : if (MaybeNewExtension(number, descriptor, &extension)) { \
300 : extension->type = type; \
301 : GOOGLE_DCHECK_EQ(cpp_type(extension->type), WireFormatLite::CPPTYPE_##UPPERCASE); \
302 : extension->is_repeated = true; \
303 : extension->is_packed = packed; \
304 : extension->repeated_##LOWERCASE##_value = new RepeatedField<LOWERCASE>(); \
305 : } else { \
306 : GOOGLE_DCHECK_TYPE(*extension, REPEATED, UPPERCASE); \
307 : GOOGLE_DCHECK_EQ(extension->is_packed, packed); \
308 : } \
309 : extension->repeated_##LOWERCASE##_value->Add(value); \
310 : }
311 :
312 0 : PRIMITIVE_ACCESSORS( INT32, int32, Int32)
313 0 : PRIMITIVE_ACCESSORS( INT64, int64, Int64)
314 0 : PRIMITIVE_ACCESSORS(UINT32, uint32, UInt32)
315 0 : PRIMITIVE_ACCESSORS(UINT64, uint64, UInt64)
316 0 : PRIMITIVE_ACCESSORS( FLOAT, float, Float)
317 0 : PRIMITIVE_ACCESSORS(DOUBLE, double, Double)
318 0 : PRIMITIVE_ACCESSORS( BOOL, bool, Bool)
319 :
320 : #undef PRIMITIVE_ACCESSORS
321 :
322 0 : const void* ExtensionSet::GetRawRepeatedField(int number,
323 : const void* default_value) const {
324 0 : map<int, Extension>::const_iterator iter = extensions_.find(number);
325 0 : if (iter == extensions_.end()) {
326 0 : return default_value;
327 : }
328 : // We assume that all the RepeatedField<>* pointers have the same
329 : // size and alignment within the anonymous union in Extension.
330 0 : return iter->second.repeated_int32_value;
331 : }
332 :
333 0 : void* ExtensionSet::MutableRawRepeatedField(int number, FieldType field_type,
334 : bool packed,
335 : const FieldDescriptor* desc) {
336 : Extension* extension;
337 :
338 : // We instantiate an empty Repeated{,Ptr}Field if one doesn't exist for this
339 : // extension.
340 0 : if (MaybeNewExtension(number, desc, &extension)) {
341 0 : extension->is_repeated = true;
342 0 : extension->type = field_type;
343 0 : extension->is_packed = packed;
344 :
345 0 : switch (WireFormatLite::FieldTypeToCppType(
346 : static_cast<WireFormatLite::FieldType>(field_type))) {
347 : case WireFormatLite::CPPTYPE_INT32:
348 0 : extension->repeated_int32_value = new RepeatedField<int32>();
349 0 : break;
350 : case WireFormatLite::CPPTYPE_INT64:
351 0 : extension->repeated_int64_value = new RepeatedField<int64>();
352 0 : break;
353 : case WireFormatLite::CPPTYPE_UINT32:
354 0 : extension->repeated_uint32_value = new RepeatedField<uint32>();
355 0 : break;
356 : case WireFormatLite::CPPTYPE_UINT64:
357 0 : extension->repeated_uint64_value = new RepeatedField<uint64>();
358 0 : break;
359 : case WireFormatLite::CPPTYPE_DOUBLE:
360 0 : extension->repeated_double_value = new RepeatedField<double>();
361 0 : break;
362 : case WireFormatLite::CPPTYPE_FLOAT:
363 0 : extension->repeated_float_value = new RepeatedField<float>();
364 0 : break;
365 : case WireFormatLite::CPPTYPE_BOOL:
366 0 : extension->repeated_bool_value = new RepeatedField<bool>();
367 0 : break;
368 : case WireFormatLite::CPPTYPE_ENUM:
369 0 : extension->repeated_enum_value = new RepeatedField<int>();
370 0 : break;
371 : case WireFormatLite::CPPTYPE_STRING:
372 0 : extension->repeated_string_value = new RepeatedPtrField< ::std::string>();
373 0 : break;
374 : case WireFormatLite::CPPTYPE_MESSAGE:
375 0 : extension->repeated_message_value = new RepeatedPtrField<MessageLite>();
376 0 : break;
377 : }
378 : }
379 :
380 : // We assume that all the RepeatedField<>* pointers have the same
381 : // size and alignment within the anonymous union in Extension.
382 0 : return extension->repeated_int32_value;
383 : }
384 :
385 : // Compatible version using old call signature. Does not create extensions when
386 : // the don't already exist; instead, just GOOGLE_CHECK-fails.
387 0 : void* ExtensionSet::MutableRawRepeatedField(int number) {
388 0 : map<int, Extension>::iterator iter = extensions_.find(number);
389 0 : GOOGLE_CHECK(iter == extensions_.end()) << "Extension not found.";
390 : // We assume that all the RepeatedField<>* pointers have the same
391 : // size and alignment within the anonymous union in Extension.
392 0 : return iter->second.repeated_int32_value;
393 : }
394 :
395 :
396 : // -------------------------------------------------------------------
397 : // Enums
398 :
399 0 : int ExtensionSet::GetEnum(int number, int default_value) const {
400 0 : map<int, Extension>::const_iterator iter = extensions_.find(number);
401 0 : if (iter == extensions_.end() || iter->second.is_cleared) {
402 : // Not present. Return the default value.
403 0 : return default_value;
404 : } else {
405 0 : GOOGLE_DCHECK_TYPE(iter->second, OPTIONAL, ENUM);
406 0 : return iter->second.enum_value;
407 : }
408 : }
409 :
410 0 : void ExtensionSet::SetEnum(int number, FieldType type, int value,
411 : const FieldDescriptor* descriptor) {
412 : Extension* extension;
413 0 : if (MaybeNewExtension(number, descriptor, &extension)) {
414 0 : extension->type = type;
415 0 : GOOGLE_DCHECK_EQ(cpp_type(extension->type), WireFormatLite::CPPTYPE_ENUM);
416 0 : extension->is_repeated = false;
417 : } else {
418 0 : GOOGLE_DCHECK_TYPE(*extension, OPTIONAL, ENUM);
419 : }
420 0 : extension->is_cleared = false;
421 0 : extension->enum_value = value;
422 0 : }
423 :
424 0 : int ExtensionSet::GetRepeatedEnum(int number, int index) const {
425 0 : map<int, Extension>::const_iterator iter = extensions_.find(number);
426 0 : GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empty).";
427 0 : GOOGLE_DCHECK_TYPE(iter->second, REPEATED, ENUM);
428 0 : return iter->second.repeated_enum_value->Get(index);
429 : }
430 :
431 0 : void ExtensionSet::SetRepeatedEnum(int number, int index, int value) {
432 0 : map<int, Extension>::iterator iter = extensions_.find(number);
433 0 : GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empty).";
434 0 : GOOGLE_DCHECK_TYPE(iter->second, REPEATED, ENUM);
435 0 : iter->second.repeated_enum_value->Set(index, value);
436 0 : }
437 :
438 0 : void ExtensionSet::AddEnum(int number, FieldType type,
439 : bool packed, int value,
440 : const FieldDescriptor* descriptor) {
441 : Extension* extension;
442 0 : if (MaybeNewExtension(number, descriptor, &extension)) {
443 0 : extension->type = type;
444 0 : GOOGLE_DCHECK_EQ(cpp_type(extension->type), WireFormatLite::CPPTYPE_ENUM);
445 0 : extension->is_repeated = true;
446 0 : extension->is_packed = packed;
447 0 : extension->repeated_enum_value = new RepeatedField<int>();
448 : } else {
449 0 : GOOGLE_DCHECK_TYPE(*extension, REPEATED, ENUM);
450 0 : GOOGLE_DCHECK_EQ(extension->is_packed, packed);
451 : }
452 0 : extension->repeated_enum_value->Add(value);
453 0 : }
454 :
455 : // -------------------------------------------------------------------
456 : // Strings
457 :
458 0 : const string& ExtensionSet::GetString(int number,
459 : const string& default_value) const {
460 0 : map<int, Extension>::const_iterator iter = extensions_.find(number);
461 0 : if (iter == extensions_.end() || iter->second.is_cleared) {
462 : // Not present. Return the default value.
463 0 : return default_value;
464 : } else {
465 0 : GOOGLE_DCHECK_TYPE(iter->second, OPTIONAL, STRING);
466 0 : return *iter->second.string_value;
467 : }
468 : }
469 :
470 0 : string* ExtensionSet::MutableString(int number, FieldType type,
471 : const FieldDescriptor* descriptor) {
472 : Extension* extension;
473 0 : if (MaybeNewExtension(number, descriptor, &extension)) {
474 0 : extension->type = type;
475 0 : GOOGLE_DCHECK_EQ(cpp_type(extension->type), WireFormatLite::CPPTYPE_STRING);
476 0 : extension->is_repeated = false;
477 0 : extension->string_value = new string;
478 : } else {
479 0 : GOOGLE_DCHECK_TYPE(*extension, OPTIONAL, STRING);
480 : }
481 0 : extension->is_cleared = false;
482 0 : return extension->string_value;
483 : }
484 :
485 0 : const string& ExtensionSet::GetRepeatedString(int number, int index) const {
486 0 : map<int, Extension>::const_iterator iter = extensions_.find(number);
487 0 : GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empty).";
488 0 : GOOGLE_DCHECK_TYPE(iter->second, REPEATED, STRING);
489 0 : return iter->second.repeated_string_value->Get(index);
490 : }
491 :
492 0 : string* ExtensionSet::MutableRepeatedString(int number, int index) {
493 0 : map<int, Extension>::iterator iter = extensions_.find(number);
494 0 : GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empty).";
495 0 : GOOGLE_DCHECK_TYPE(iter->second, REPEATED, STRING);
496 0 : return iter->second.repeated_string_value->Mutable(index);
497 : }
498 :
499 0 : string* ExtensionSet::AddString(int number, FieldType type,
500 : const FieldDescriptor* descriptor) {
501 : Extension* extension;
502 0 : if (MaybeNewExtension(number, descriptor, &extension)) {
503 0 : extension->type = type;
504 0 : GOOGLE_DCHECK_EQ(cpp_type(extension->type), WireFormatLite::CPPTYPE_STRING);
505 0 : extension->is_repeated = true;
506 0 : extension->is_packed = false;
507 0 : extension->repeated_string_value = new RepeatedPtrField<string>();
508 : } else {
509 0 : GOOGLE_DCHECK_TYPE(*extension, REPEATED, STRING);
510 : }
511 0 : return extension->repeated_string_value->Add();
512 : }
513 :
514 : // -------------------------------------------------------------------
515 : // Messages
516 :
517 0 : const MessageLite& ExtensionSet::GetMessage(
518 : int number, const MessageLite& default_value) const {
519 0 : map<int, Extension>::const_iterator iter = extensions_.find(number);
520 0 : if (iter == extensions_.end()) {
521 : // Not present. Return the default value.
522 0 : return default_value;
523 : } else {
524 0 : GOOGLE_DCHECK_TYPE(iter->second, OPTIONAL, MESSAGE);
525 0 : if (iter->second.is_lazy) {
526 0 : return iter->second.lazymessage_value->GetMessage(default_value);
527 : } else {
528 0 : return *iter->second.message_value;
529 : }
530 : }
531 : }
532 :
533 : // Defined in extension_set_heavy.cc.
534 : // const MessageLite& ExtensionSet::GetMessage(int number,
535 : // const Descriptor* message_type,
536 : // MessageFactory* factory) const
537 :
538 0 : MessageLite* ExtensionSet::MutableMessage(int number, FieldType type,
539 : const MessageLite& prototype,
540 : const FieldDescriptor* descriptor) {
541 : Extension* extension;
542 0 : if (MaybeNewExtension(number, descriptor, &extension)) {
543 0 : extension->type = type;
544 0 : GOOGLE_DCHECK_EQ(cpp_type(extension->type), WireFormatLite::CPPTYPE_MESSAGE);
545 0 : extension->is_repeated = false;
546 0 : extension->is_lazy = false;
547 0 : extension->message_value = prototype.New();
548 0 : extension->is_cleared = false;
549 0 : return extension->message_value;
550 : } else {
551 0 : GOOGLE_DCHECK_TYPE(*extension, OPTIONAL, MESSAGE);
552 0 : extension->is_cleared = false;
553 0 : if (extension->is_lazy) {
554 0 : return extension->lazymessage_value->MutableMessage(prototype);
555 : } else {
556 0 : return extension->message_value;
557 : }
558 : }
559 : }
560 :
561 : // Defined in extension_set_heavy.cc.
562 : // MessageLite* ExtensionSet::MutableMessage(int number, FieldType type,
563 : // const Descriptor* message_type,
564 : // MessageFactory* factory)
565 :
566 0 : void ExtensionSet::SetAllocatedMessage(int number, FieldType type,
567 : const FieldDescriptor* descriptor,
568 : MessageLite* message) {
569 0 : if (message == NULL) {
570 0 : ClearExtension(number);
571 0 : return;
572 : }
573 : Extension* extension;
574 0 : if (MaybeNewExtension(number, descriptor, &extension)) {
575 0 : extension->type = type;
576 0 : GOOGLE_DCHECK_EQ(cpp_type(extension->type), WireFormatLite::CPPTYPE_MESSAGE);
577 0 : extension->is_repeated = false;
578 0 : extension->is_lazy = false;
579 0 : extension->message_value = message;
580 : } else {
581 0 : GOOGLE_DCHECK_TYPE(*extension, OPTIONAL, MESSAGE);
582 0 : if (extension->is_lazy) {
583 0 : extension->lazymessage_value->SetAllocatedMessage(message);
584 : } else {
585 0 : delete extension->message_value;
586 0 : extension->message_value = message;
587 : }
588 : }
589 0 : extension->is_cleared = false;
590 : }
591 :
592 0 : MessageLite* ExtensionSet::ReleaseMessage(int number,
593 : const MessageLite& prototype) {
594 0 : map<int, Extension>::iterator iter = extensions_.find(number);
595 0 : if (iter == extensions_.end()) {
596 : // Not present. Return NULL.
597 0 : return NULL;
598 : } else {
599 0 : GOOGLE_DCHECK_TYPE(iter->second, OPTIONAL, MESSAGE);
600 0 : MessageLite* ret = NULL;
601 0 : if (iter->second.is_lazy) {
602 0 : ret = iter->second.lazymessage_value->ReleaseMessage(prototype);
603 0 : delete iter->second.lazymessage_value;
604 : } else {
605 0 : ret = iter->second.message_value;
606 : }
607 0 : extensions_.erase(number);
608 0 : return ret;
609 : }
610 : }
611 :
612 : // Defined in extension_set_heavy.cc.
613 : // MessageLite* ExtensionSet::ReleaseMessage(const FieldDescriptor* descriptor,
614 : // MessageFactory* factory);
615 :
616 0 : const MessageLite& ExtensionSet::GetRepeatedMessage(
617 : int number, int index) const {
618 0 : map<int, Extension>::const_iterator iter = extensions_.find(number);
619 0 : GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empty).";
620 0 : GOOGLE_DCHECK_TYPE(iter->second, REPEATED, MESSAGE);
621 0 : return iter->second.repeated_message_value->Get(index);
622 : }
623 :
624 0 : MessageLite* ExtensionSet::MutableRepeatedMessage(int number, int index) {
625 0 : map<int, Extension>::iterator iter = extensions_.find(number);
626 0 : GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empty).";
627 0 : GOOGLE_DCHECK_TYPE(iter->second, REPEATED, MESSAGE);
628 0 : return iter->second.repeated_message_value->Mutable(index);
629 : }
630 :
631 0 : MessageLite* ExtensionSet::AddMessage(int number, FieldType type,
632 : const MessageLite& prototype,
633 : const FieldDescriptor* descriptor) {
634 : Extension* extension;
635 0 : if (MaybeNewExtension(number, descriptor, &extension)) {
636 0 : extension->type = type;
637 0 : GOOGLE_DCHECK_EQ(cpp_type(extension->type), WireFormatLite::CPPTYPE_MESSAGE);
638 0 : extension->is_repeated = true;
639 0 : extension->repeated_message_value =
640 0 : new RepeatedPtrField<MessageLite>();
641 : } else {
642 0 : GOOGLE_DCHECK_TYPE(*extension, REPEATED, MESSAGE);
643 : }
644 :
645 : // RepeatedPtrField<MessageLite> does not know how to Add() since it cannot
646 : // allocate an abstract object, so we have to be tricky.
647 0 : MessageLite* result = extension->repeated_message_value
648 0 : ->AddFromCleared<GenericTypeHandler<MessageLite> >();
649 0 : if (result == NULL) {
650 0 : result = prototype.New();
651 0 : extension->repeated_message_value->AddAllocated(result);
652 : }
653 0 : return result;
654 : }
655 :
656 : // Defined in extension_set_heavy.cc.
657 : // MessageLite* ExtensionSet::AddMessage(int number, FieldType type,
658 : // const Descriptor* message_type,
659 : // MessageFactory* factory)
660 :
661 : #undef GOOGLE_DCHECK_TYPE
662 :
663 0 : void ExtensionSet::RemoveLast(int number) {
664 0 : map<int, Extension>::iterator iter = extensions_.find(number);
665 0 : GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empty).";
666 :
667 0 : Extension* extension = &iter->second;
668 0 : GOOGLE_DCHECK(extension->is_repeated);
669 :
670 0 : switch(cpp_type(extension->type)) {
671 : case WireFormatLite::CPPTYPE_INT32:
672 0 : extension->repeated_int32_value->RemoveLast();
673 0 : break;
674 : case WireFormatLite::CPPTYPE_INT64:
675 0 : extension->repeated_int64_value->RemoveLast();
676 0 : break;
677 : case WireFormatLite::CPPTYPE_UINT32:
678 0 : extension->repeated_uint32_value->RemoveLast();
679 0 : break;
680 : case WireFormatLite::CPPTYPE_UINT64:
681 0 : extension->repeated_uint64_value->RemoveLast();
682 0 : break;
683 : case WireFormatLite::CPPTYPE_FLOAT:
684 0 : extension->repeated_float_value->RemoveLast();
685 0 : break;
686 : case WireFormatLite::CPPTYPE_DOUBLE:
687 0 : extension->repeated_double_value->RemoveLast();
688 0 : break;
689 : case WireFormatLite::CPPTYPE_BOOL:
690 0 : extension->repeated_bool_value->RemoveLast();
691 0 : break;
692 : case WireFormatLite::CPPTYPE_ENUM:
693 0 : extension->repeated_enum_value->RemoveLast();
694 0 : break;
695 : case WireFormatLite::CPPTYPE_STRING:
696 0 : extension->repeated_string_value->RemoveLast();
697 0 : break;
698 : case WireFormatLite::CPPTYPE_MESSAGE:
699 0 : extension->repeated_message_value->RemoveLast();
700 0 : break;
701 : }
702 0 : }
703 :
704 0 : MessageLite* ExtensionSet::ReleaseLast(int number) {
705 0 : map<int, Extension>::iterator iter = extensions_.find(number);
706 0 : GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empty).";
707 :
708 0 : Extension* extension = &iter->second;
709 0 : GOOGLE_DCHECK(extension->is_repeated);
710 0 : GOOGLE_DCHECK(cpp_type(extension->type) == WireFormatLite::CPPTYPE_MESSAGE);
711 0 : return extension->repeated_message_value->ReleaseLast();
712 : }
713 :
714 0 : void ExtensionSet::SwapElements(int number, int index1, int index2) {
715 0 : map<int, Extension>::iterator iter = extensions_.find(number);
716 0 : GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empty).";
717 :
718 0 : Extension* extension = &iter->second;
719 0 : GOOGLE_DCHECK(extension->is_repeated);
720 :
721 0 : switch(cpp_type(extension->type)) {
722 : case WireFormatLite::CPPTYPE_INT32:
723 0 : extension->repeated_int32_value->SwapElements(index1, index2);
724 0 : break;
725 : case WireFormatLite::CPPTYPE_INT64:
726 0 : extension->repeated_int64_value->SwapElements(index1, index2);
727 0 : break;
728 : case WireFormatLite::CPPTYPE_UINT32:
729 0 : extension->repeated_uint32_value->SwapElements(index1, index2);
730 0 : break;
731 : case WireFormatLite::CPPTYPE_UINT64:
732 0 : extension->repeated_uint64_value->SwapElements(index1, index2);
733 0 : break;
734 : case WireFormatLite::CPPTYPE_FLOAT:
735 0 : extension->repeated_float_value->SwapElements(index1, index2);
736 0 : break;
737 : case WireFormatLite::CPPTYPE_DOUBLE:
738 0 : extension->repeated_double_value->SwapElements(index1, index2);
739 0 : break;
740 : case WireFormatLite::CPPTYPE_BOOL:
741 0 : extension->repeated_bool_value->SwapElements(index1, index2);
742 0 : break;
743 : case WireFormatLite::CPPTYPE_ENUM:
744 0 : extension->repeated_enum_value->SwapElements(index1, index2);
745 0 : break;
746 : case WireFormatLite::CPPTYPE_STRING:
747 0 : extension->repeated_string_value->SwapElements(index1, index2);
748 0 : break;
749 : case WireFormatLite::CPPTYPE_MESSAGE:
750 0 : extension->repeated_message_value->SwapElements(index1, index2);
751 0 : break;
752 : }
753 0 : }
754 :
755 : // ===================================================================
756 :
757 0 : void ExtensionSet::Clear() {
758 0 : for (map<int, Extension>::iterator iter = extensions_.begin();
759 0 : iter != extensions_.end(); ++iter) {
760 0 : iter->second.Clear();
761 : }
762 0 : }
763 :
764 0 : void ExtensionSet::MergeFrom(const ExtensionSet& other) {
765 0 : for (map<int, Extension>::const_iterator iter = other.extensions_.begin();
766 0 : iter != other.extensions_.end(); ++iter) {
767 0 : const Extension& other_extension = iter->second;
768 :
769 0 : if (other_extension.is_repeated) {
770 : Extension* extension;
771 0 : bool is_new = MaybeNewExtension(iter->first, other_extension.descriptor,
772 0 : &extension);
773 0 : if (is_new) {
774 : // Extension did not already exist in set.
775 0 : extension->type = other_extension.type;
776 0 : extension->is_packed = other_extension.is_packed;
777 0 : extension->is_repeated = true;
778 : } else {
779 0 : GOOGLE_DCHECK_EQ(extension->type, other_extension.type);
780 0 : GOOGLE_DCHECK_EQ(extension->is_packed, other_extension.is_packed);
781 0 : GOOGLE_DCHECK(extension->is_repeated);
782 : }
783 :
784 0 : switch (cpp_type(other_extension.type)) {
785 : #define HANDLE_TYPE(UPPERCASE, LOWERCASE, REPEATED_TYPE) \
786 : case WireFormatLite::CPPTYPE_##UPPERCASE: \
787 : if (is_new) { \
788 : extension->repeated_##LOWERCASE##_value = \
789 : new REPEATED_TYPE; \
790 : } \
791 : extension->repeated_##LOWERCASE##_value->MergeFrom( \
792 : *other_extension.repeated_##LOWERCASE##_value); \
793 : break;
794 :
795 0 : HANDLE_TYPE( INT32, int32, RepeatedField < int32>);
796 0 : HANDLE_TYPE( INT64, int64, RepeatedField < int64>);
797 0 : HANDLE_TYPE( UINT32, uint32, RepeatedField < uint32>);
798 0 : HANDLE_TYPE( UINT64, uint64, RepeatedField < uint64>);
799 0 : HANDLE_TYPE( FLOAT, float, RepeatedField < float>);
800 0 : HANDLE_TYPE( DOUBLE, double, RepeatedField < double>);
801 0 : HANDLE_TYPE( BOOL, bool, RepeatedField < bool>);
802 0 : HANDLE_TYPE( ENUM, enum, RepeatedField < int>);
803 0 : HANDLE_TYPE( STRING, string, RepeatedPtrField< string>);
804 : #undef HANDLE_TYPE
805 :
806 : case WireFormatLite::CPPTYPE_MESSAGE:
807 0 : if (is_new) {
808 0 : extension->repeated_message_value =
809 0 : new RepeatedPtrField<MessageLite>();
810 : }
811 : // We can't call RepeatedPtrField<MessageLite>::MergeFrom() because
812 : // it would attempt to allocate new objects.
813 : RepeatedPtrField<MessageLite>* other_repeated_message =
814 0 : other_extension.repeated_message_value;
815 0 : for (int i = 0; i < other_repeated_message->size(); i++) {
816 0 : const MessageLite& other_message = other_repeated_message->Get(i);
817 0 : MessageLite* target = extension->repeated_message_value
818 0 : ->AddFromCleared<GenericTypeHandler<MessageLite> >();
819 0 : if (target == NULL) {
820 0 : target = other_message.New();
821 0 : extension->repeated_message_value->AddAllocated(target);
822 : }
823 0 : target->CheckTypeAndMergeFrom(other_message);
824 : }
825 0 : break;
826 : }
827 : } else {
828 0 : if (!other_extension.is_cleared) {
829 0 : switch (cpp_type(other_extension.type)) {
830 : #define HANDLE_TYPE(UPPERCASE, LOWERCASE, CAMELCASE) \
831 : case WireFormatLite::CPPTYPE_##UPPERCASE: \
832 : Set##CAMELCASE(iter->first, other_extension.type, \
833 : other_extension.LOWERCASE##_value, \
834 : other_extension.descriptor); \
835 : break;
836 :
837 0 : HANDLE_TYPE( INT32, int32, Int32);
838 0 : HANDLE_TYPE( INT64, int64, Int64);
839 0 : HANDLE_TYPE(UINT32, uint32, UInt32);
840 0 : HANDLE_TYPE(UINT64, uint64, UInt64);
841 0 : HANDLE_TYPE( FLOAT, float, Float);
842 0 : HANDLE_TYPE(DOUBLE, double, Double);
843 0 : HANDLE_TYPE( BOOL, bool, Bool);
844 0 : HANDLE_TYPE( ENUM, enum, Enum);
845 : #undef HANDLE_TYPE
846 : case WireFormatLite::CPPTYPE_STRING:
847 0 : SetString(iter->first, other_extension.type,
848 0 : *other_extension.string_value,
849 0 : other_extension.descriptor);
850 0 : break;
851 : case WireFormatLite::CPPTYPE_MESSAGE: {
852 : Extension* extension;
853 0 : bool is_new = MaybeNewExtension(iter->first,
854 0 : other_extension.descriptor,
855 0 : &extension);
856 0 : if (is_new) {
857 0 : extension->type = other_extension.type;
858 0 : extension->is_packed = other_extension.is_packed;
859 0 : extension->is_repeated = false;
860 0 : if (other_extension.is_lazy) {
861 0 : extension->is_lazy = true;
862 0 : extension->lazymessage_value =
863 0 : other_extension.lazymessage_value->New();
864 0 : extension->lazymessage_value->MergeFrom(
865 0 : *other_extension.lazymessage_value);
866 : } else {
867 0 : extension->is_lazy = false;
868 0 : extension->message_value =
869 0 : other_extension.message_value->New();
870 0 : extension->message_value->CheckTypeAndMergeFrom(
871 0 : *other_extension.message_value);
872 : }
873 : } else {
874 0 : GOOGLE_DCHECK_EQ(extension->type, other_extension.type);
875 0 : GOOGLE_DCHECK_EQ(extension->is_packed,other_extension.is_packed);
876 0 : GOOGLE_DCHECK(!extension->is_repeated);
877 0 : if (other_extension.is_lazy) {
878 0 : if (extension->is_lazy) {
879 0 : extension->lazymessage_value->MergeFrom(
880 0 : *other_extension.lazymessage_value);
881 : } else {
882 0 : extension->message_value->CheckTypeAndMergeFrom(
883 0 : other_extension.lazymessage_value->GetMessage(
884 0 : *extension->message_value));
885 : }
886 : } else {
887 0 : if (extension->is_lazy) {
888 0 : extension->lazymessage_value->MutableMessage(
889 0 : *other_extension.message_value)->CheckTypeAndMergeFrom(
890 0 : *other_extension.message_value);
891 : } else {
892 0 : extension->message_value->CheckTypeAndMergeFrom(
893 0 : *other_extension.message_value);
894 : }
895 : }
896 : }
897 0 : extension->is_cleared = false;
898 0 : break;
899 : }
900 : }
901 : }
902 : }
903 : }
904 0 : }
905 :
906 0 : void ExtensionSet::Swap(ExtensionSet* x) {
907 0 : extensions_.swap(x->extensions_);
908 0 : }
909 :
910 0 : void ExtensionSet::SwapExtension(ExtensionSet* other,
911 : int number) {
912 0 : if (this == other) return;
913 0 : map<int, Extension>::iterator this_iter = extensions_.find(number);
914 0 : map<int, Extension>::iterator other_iter = other->extensions_.find(number);
915 :
916 0 : if (this_iter == extensions_.end() &&
917 0 : other_iter == other->extensions_.end()) {
918 0 : return;
919 : }
920 :
921 0 : if (this_iter != extensions_.end() &&
922 0 : other_iter != other->extensions_.end()) {
923 0 : std::swap(this_iter->second, other_iter->second);
924 0 : return;
925 : }
926 :
927 0 : if (this_iter == extensions_.end()) {
928 0 : extensions_.insert(make_pair(number, other_iter->second));
929 0 : other->extensions_.erase(number);
930 0 : return;
931 : }
932 :
933 0 : if (other_iter == other->extensions_.end()) {
934 0 : other->extensions_.insert(make_pair(number, this_iter->second));
935 0 : extensions_.erase(number);
936 0 : return;
937 : }
938 : }
939 :
940 9 : bool ExtensionSet::IsInitialized() const {
941 : // Extensions are never required. However, we need to check that all
942 : // embedded messages are initialized.
943 27 : for (map<int, Extension>::const_iterator iter = extensions_.begin();
944 18 : iter != extensions_.end(); ++iter) {
945 0 : const Extension& extension = iter->second;
946 0 : if (cpp_type(extension.type) == WireFormatLite::CPPTYPE_MESSAGE) {
947 0 : if (extension.is_repeated) {
948 0 : for (int i = 0; i < extension.repeated_message_value->size(); i++) {
949 0 : if (!extension.repeated_message_value->Get(i).IsInitialized()) {
950 0 : return false;
951 : }
952 : }
953 : } else {
954 0 : if (!extension.is_cleared) {
955 0 : if (extension.is_lazy) {
956 0 : if (!extension.lazymessage_value->IsInitialized()) return false;
957 : } else {
958 0 : if (!extension.message_value->IsInitialized()) return false;
959 : }
960 : }
961 : }
962 : }
963 : }
964 :
965 9 : return true;
966 : }
967 :
968 0 : bool ExtensionSet::FindExtensionInfoFromTag(
969 : uint32 tag, ExtensionFinder* extension_finder, int* field_number,
970 : ExtensionInfo* extension, bool* was_packed_on_wire) {
971 0 : *field_number = WireFormatLite::GetTagFieldNumber(tag);
972 0 : WireFormatLite::WireType wire_type = WireFormatLite::GetTagWireType(tag);
973 0 : return FindExtensionInfoFromFieldNumber(wire_type, *field_number,
974 : extension_finder, extension,
975 0 : was_packed_on_wire);
976 : }
977 :
978 0 : bool ExtensionSet::FindExtensionInfoFromFieldNumber(
979 : int wire_type, int field_number, ExtensionFinder* extension_finder,
980 : ExtensionInfo* extension, bool* was_packed_on_wire) {
981 0 : if (!extension_finder->Find(field_number, extension)) {
982 0 : return false;
983 : }
984 :
985 : WireFormatLite::WireType expected_wire_type =
986 0 : WireFormatLite::WireTypeForFieldType(real_type(extension->type));
987 :
988 : // Check if this is a packed field.
989 0 : *was_packed_on_wire = false;
990 0 : if (extension->is_repeated &&
991 0 : wire_type == WireFormatLite::WIRETYPE_LENGTH_DELIMITED &&
992 0 : is_packable(expected_wire_type)) {
993 0 : *was_packed_on_wire = true;
994 0 : return true;
995 : }
996 : // Otherwise the wire type must match.
997 0 : return expected_wire_type == wire_type;
998 : }
999 :
1000 0 : bool ExtensionSet::ParseField(uint32 tag, io::CodedInputStream* input,
1001 : ExtensionFinder* extension_finder,
1002 : FieldSkipper* field_skipper) {
1003 : int number;
1004 : bool was_packed_on_wire;
1005 0 : ExtensionInfo extension;
1006 0 : if (!FindExtensionInfoFromTag(
1007 : tag, extension_finder, &number, &extension, &was_packed_on_wire)) {
1008 0 : return field_skipper->SkipField(input, tag);
1009 : } else {
1010 0 : return ParseFieldWithExtensionInfo(
1011 0 : number, was_packed_on_wire, extension, input, field_skipper);
1012 : }
1013 : }
1014 :
1015 0 : bool ExtensionSet::ParseFieldWithExtensionInfo(
1016 : int number, bool was_packed_on_wire, const ExtensionInfo& extension,
1017 : io::CodedInputStream* input,
1018 : FieldSkipper* field_skipper) {
1019 : // Explicitly not read extension.is_packed, instead check whether the field
1020 : // was encoded in packed form on the wire.
1021 0 : if (was_packed_on_wire) {
1022 : uint32 size;
1023 0 : if (!input->ReadVarint32(&size)) return false;
1024 0 : io::CodedInputStream::Limit limit = input->PushLimit(size);
1025 :
1026 0 : switch (extension.type) {
1027 : #define HANDLE_TYPE(UPPERCASE, CPP_CAMELCASE, CPP_LOWERCASE) \
1028 : case WireFormatLite::TYPE_##UPPERCASE: \
1029 : while (input->BytesUntilLimit() > 0) { \
1030 : CPP_LOWERCASE value; \
1031 : if (!WireFormatLite::ReadPrimitive< \
1032 : CPP_LOWERCASE, WireFormatLite::TYPE_##UPPERCASE>( \
1033 : input, &value)) return false; \
1034 : Add##CPP_CAMELCASE(number, WireFormatLite::TYPE_##UPPERCASE, \
1035 : extension.is_packed, value, \
1036 : extension.descriptor); \
1037 : } \
1038 : break
1039 :
1040 0 : HANDLE_TYPE( INT32, Int32, int32);
1041 0 : HANDLE_TYPE( INT64, Int64, int64);
1042 0 : HANDLE_TYPE( UINT32, UInt32, uint32);
1043 0 : HANDLE_TYPE( UINT64, UInt64, uint64);
1044 0 : HANDLE_TYPE( SINT32, Int32, int32);
1045 0 : HANDLE_TYPE( SINT64, Int64, int64);
1046 0 : HANDLE_TYPE( FIXED32, UInt32, uint32);
1047 0 : HANDLE_TYPE( FIXED64, UInt64, uint64);
1048 0 : HANDLE_TYPE(SFIXED32, Int32, int32);
1049 0 : HANDLE_TYPE(SFIXED64, Int64, int64);
1050 0 : HANDLE_TYPE( FLOAT, Float, float);
1051 0 : HANDLE_TYPE( DOUBLE, Double, double);
1052 0 : HANDLE_TYPE( BOOL, Bool, bool);
1053 : #undef HANDLE_TYPE
1054 :
1055 : case WireFormatLite::TYPE_ENUM:
1056 0 : while (input->BytesUntilLimit() > 0) {
1057 : int value;
1058 0 : if (!WireFormatLite::ReadPrimitive<int, WireFormatLite::TYPE_ENUM>(
1059 0 : input, &value)) return false;
1060 0 : if (extension.enum_validity_check.func(
1061 0 : extension.enum_validity_check.arg, value)) {
1062 0 : AddEnum(number, WireFormatLite::TYPE_ENUM, extension.is_packed,
1063 0 : value, extension.descriptor);
1064 : }
1065 : }
1066 0 : break;
1067 :
1068 : case WireFormatLite::TYPE_STRING:
1069 : case WireFormatLite::TYPE_BYTES:
1070 : case WireFormatLite::TYPE_GROUP:
1071 : case WireFormatLite::TYPE_MESSAGE:
1072 0 : GOOGLE_LOG(FATAL) << "Non-primitive types can't be packed.";
1073 0 : break;
1074 : }
1075 :
1076 0 : input->PopLimit(limit);
1077 : } else {
1078 0 : switch (extension.type) {
1079 : #define HANDLE_TYPE(UPPERCASE, CPP_CAMELCASE, CPP_LOWERCASE) \
1080 : case WireFormatLite::TYPE_##UPPERCASE: { \
1081 : CPP_LOWERCASE value; \
1082 : if (!WireFormatLite::ReadPrimitive< \
1083 : CPP_LOWERCASE, WireFormatLite::TYPE_##UPPERCASE>( \
1084 : input, &value)) return false; \
1085 : if (extension.is_repeated) { \
1086 : Add##CPP_CAMELCASE(number, WireFormatLite::TYPE_##UPPERCASE, \
1087 : extension.is_packed, value, \
1088 : extension.descriptor); \
1089 : } else { \
1090 : Set##CPP_CAMELCASE(number, WireFormatLite::TYPE_##UPPERCASE, value, \
1091 : extension.descriptor); \
1092 : } \
1093 : } break
1094 :
1095 0 : HANDLE_TYPE( INT32, Int32, int32);
1096 0 : HANDLE_TYPE( INT64, Int64, int64);
1097 0 : HANDLE_TYPE( UINT32, UInt32, uint32);
1098 0 : HANDLE_TYPE( UINT64, UInt64, uint64);
1099 0 : HANDLE_TYPE( SINT32, Int32, int32);
1100 0 : HANDLE_TYPE( SINT64, Int64, int64);
1101 0 : HANDLE_TYPE( FIXED32, UInt32, uint32);
1102 0 : HANDLE_TYPE( FIXED64, UInt64, uint64);
1103 0 : HANDLE_TYPE(SFIXED32, Int32, int32);
1104 0 : HANDLE_TYPE(SFIXED64, Int64, int64);
1105 0 : HANDLE_TYPE( FLOAT, Float, float);
1106 0 : HANDLE_TYPE( DOUBLE, Double, double);
1107 0 : HANDLE_TYPE( BOOL, Bool, bool);
1108 : #undef HANDLE_TYPE
1109 :
1110 : case WireFormatLite::TYPE_ENUM: {
1111 : int value;
1112 0 : if (!WireFormatLite::ReadPrimitive<int, WireFormatLite::TYPE_ENUM>(
1113 0 : input, &value)) return false;
1114 :
1115 0 : if (!extension.enum_validity_check.func(
1116 0 : extension.enum_validity_check.arg, value)) {
1117 : // Invalid value. Treat as unknown.
1118 0 : field_skipper->SkipUnknownEnum(number, value);
1119 0 : } else if (extension.is_repeated) {
1120 0 : AddEnum(number, WireFormatLite::TYPE_ENUM, extension.is_packed, value,
1121 0 : extension.descriptor);
1122 : } else {
1123 : SetEnum(number, WireFormatLite::TYPE_ENUM, value,
1124 0 : extension.descriptor);
1125 : }
1126 0 : break;
1127 : }
1128 :
1129 : case WireFormatLite::TYPE_STRING: {
1130 0 : string* value = extension.is_repeated ?
1131 0 : AddString(number, WireFormatLite::TYPE_STRING, extension.descriptor) :
1132 : MutableString(number, WireFormatLite::TYPE_STRING,
1133 0 : extension.descriptor);
1134 0 : if (!WireFormatLite::ReadString(input, value)) return false;
1135 0 : break;
1136 : }
1137 :
1138 : case WireFormatLite::TYPE_BYTES: {
1139 0 : string* value = extension.is_repeated ?
1140 0 : AddString(number, WireFormatLite::TYPE_BYTES, extension.descriptor) :
1141 : MutableString(number, WireFormatLite::TYPE_BYTES,
1142 0 : extension.descriptor);
1143 0 : if (!WireFormatLite::ReadBytes(input, value)) return false;
1144 0 : break;
1145 : }
1146 :
1147 : case WireFormatLite::TYPE_GROUP: {
1148 0 : MessageLite* value = extension.is_repeated ?
1149 : AddMessage(number, WireFormatLite::TYPE_GROUP,
1150 0 : *extension.message_prototype, extension.descriptor) :
1151 : MutableMessage(number, WireFormatLite::TYPE_GROUP,
1152 0 : *extension.message_prototype, extension.descriptor);
1153 0 : if (!WireFormatLite::ReadGroup(number, input, value)) return false;
1154 0 : break;
1155 : }
1156 :
1157 : case WireFormatLite::TYPE_MESSAGE: {
1158 0 : MessageLite* value = extension.is_repeated ?
1159 : AddMessage(number, WireFormatLite::TYPE_MESSAGE,
1160 0 : *extension.message_prototype, extension.descriptor) :
1161 : MutableMessage(number, WireFormatLite::TYPE_MESSAGE,
1162 0 : *extension.message_prototype, extension.descriptor);
1163 0 : if (!WireFormatLite::ReadMessage(input, value)) return false;
1164 0 : break;
1165 : }
1166 : }
1167 : }
1168 :
1169 0 : return true;
1170 : }
1171 :
1172 0 : bool ExtensionSet::ParseField(uint32 tag, io::CodedInputStream* input,
1173 : const MessageLite* containing_type) {
1174 0 : FieldSkipper skipper;
1175 0 : GeneratedExtensionFinder finder(containing_type);
1176 0 : return ParseField(tag, input, &finder, &skipper);
1177 : }
1178 :
1179 0 : bool ExtensionSet::ParseField(uint32 tag, io::CodedInputStream* input,
1180 : const MessageLite* containing_type,
1181 : io::CodedOutputStream* unknown_fields) {
1182 0 : CodedOutputStreamFieldSkipper skipper(unknown_fields);
1183 0 : GeneratedExtensionFinder finder(containing_type);
1184 0 : return ParseField(tag, input, &finder, &skipper);
1185 : }
1186 :
1187 : // Defined in extension_set_heavy.cc.
1188 : // bool ExtensionSet::ParseField(uint32 tag, io::CodedInputStream* input,
1189 : // const MessageLite* containing_type,
1190 : // UnknownFieldSet* unknown_fields)
1191 :
1192 : // Defined in extension_set_heavy.cc.
1193 : // bool ExtensionSet::ParseMessageSet(io::CodedInputStream* input,
1194 : // const MessageLite* containing_type,
1195 : // UnknownFieldSet* unknown_fields);
1196 :
1197 0 : void ExtensionSet::SerializeWithCachedSizes(
1198 : int start_field_number, int end_field_number,
1199 : io::CodedOutputStream* output) const {
1200 0 : map<int, Extension>::const_iterator iter;
1201 0 : for (iter = extensions_.lower_bound(start_field_number);
1202 0 : iter != extensions_.end() && iter->first < end_field_number;
1203 : ++iter) {
1204 0 : iter->second.SerializeFieldWithCachedSizes(iter->first, output);
1205 : }
1206 0 : }
1207 :
1208 0 : int ExtensionSet::ByteSize() const {
1209 0 : int total_size = 0;
1210 :
1211 0 : for (map<int, Extension>::const_iterator iter = extensions_.begin();
1212 0 : iter != extensions_.end(); ++iter) {
1213 0 : total_size += iter->second.ByteSize(iter->first);
1214 : }
1215 :
1216 0 : return total_size;
1217 : }
1218 :
1219 : // Defined in extension_set_heavy.cc.
1220 : // int ExtensionSet::SpaceUsedExcludingSelf() const
1221 :
1222 0 : bool ExtensionSet::MaybeNewExtension(int number,
1223 : const FieldDescriptor* descriptor,
1224 : Extension** result) {
1225 : pair<map<int, Extension>::iterator, bool> insert_result =
1226 0 : extensions_.insert(make_pair(number, Extension()));
1227 0 : *result = &insert_result.first->second;
1228 0 : (*result)->descriptor = descriptor;
1229 0 : return insert_result.second;
1230 : }
1231 :
1232 : // ===================================================================
1233 : // Methods of ExtensionSet::Extension
1234 :
1235 0 : void ExtensionSet::Extension::Clear() {
1236 0 : if (is_repeated) {
1237 0 : switch (cpp_type(type)) {
1238 : #define HANDLE_TYPE(UPPERCASE, LOWERCASE) \
1239 : case WireFormatLite::CPPTYPE_##UPPERCASE: \
1240 : repeated_##LOWERCASE##_value->Clear(); \
1241 : break
1242 :
1243 0 : HANDLE_TYPE( INT32, int32);
1244 0 : HANDLE_TYPE( INT64, int64);
1245 0 : HANDLE_TYPE( UINT32, uint32);
1246 0 : HANDLE_TYPE( UINT64, uint64);
1247 0 : HANDLE_TYPE( FLOAT, float);
1248 0 : HANDLE_TYPE( DOUBLE, double);
1249 0 : HANDLE_TYPE( BOOL, bool);
1250 0 : HANDLE_TYPE( ENUM, enum);
1251 0 : HANDLE_TYPE( STRING, string);
1252 0 : HANDLE_TYPE(MESSAGE, message);
1253 : #undef HANDLE_TYPE
1254 : }
1255 : } else {
1256 0 : if (!is_cleared) {
1257 0 : switch (cpp_type(type)) {
1258 : case WireFormatLite::CPPTYPE_STRING:
1259 0 : string_value->clear();
1260 0 : break;
1261 : case WireFormatLite::CPPTYPE_MESSAGE:
1262 0 : if (is_lazy) {
1263 0 : lazymessage_value->Clear();
1264 : } else {
1265 0 : message_value->Clear();
1266 : }
1267 0 : break;
1268 : default:
1269 : // No need to do anything. Get*() will return the default value
1270 : // as long as is_cleared is true and Set*() will overwrite the
1271 : // previous value.
1272 0 : break;
1273 : }
1274 :
1275 0 : is_cleared = true;
1276 : }
1277 : }
1278 0 : }
1279 :
1280 0 : void ExtensionSet::Extension::SerializeFieldWithCachedSizes(
1281 : int number,
1282 : io::CodedOutputStream* output) const {
1283 0 : if (is_repeated) {
1284 0 : if (is_packed) {
1285 0 : if (cached_size == 0) return;
1286 :
1287 : WireFormatLite::WriteTag(number,
1288 : WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
1289 0 : output->WriteVarint32(cached_size);
1290 :
1291 0 : switch (real_type(type)) {
1292 : #define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \
1293 : case WireFormatLite::TYPE_##UPPERCASE: \
1294 : for (int i = 0; i < repeated_##LOWERCASE##_value->size(); i++) { \
1295 : WireFormatLite::Write##CAMELCASE##NoTag( \
1296 : repeated_##LOWERCASE##_value->Get(i), output); \
1297 : } \
1298 : break
1299 :
1300 0 : HANDLE_TYPE( INT32, Int32, int32);
1301 0 : HANDLE_TYPE( INT64, Int64, int64);
1302 0 : HANDLE_TYPE( UINT32, UInt32, uint32);
1303 0 : HANDLE_TYPE( UINT64, UInt64, uint64);
1304 0 : HANDLE_TYPE( SINT32, SInt32, int32);
1305 0 : HANDLE_TYPE( SINT64, SInt64, int64);
1306 0 : HANDLE_TYPE( FIXED32, Fixed32, uint32);
1307 0 : HANDLE_TYPE( FIXED64, Fixed64, uint64);
1308 0 : HANDLE_TYPE(SFIXED32, SFixed32, int32);
1309 0 : HANDLE_TYPE(SFIXED64, SFixed64, int64);
1310 0 : HANDLE_TYPE( FLOAT, Float, float);
1311 0 : HANDLE_TYPE( DOUBLE, Double, double);
1312 0 : HANDLE_TYPE( BOOL, Bool, bool);
1313 0 : HANDLE_TYPE( ENUM, Enum, enum);
1314 : #undef HANDLE_TYPE
1315 :
1316 : case WireFormatLite::TYPE_STRING:
1317 : case WireFormatLite::TYPE_BYTES:
1318 : case WireFormatLite::TYPE_GROUP:
1319 : case WireFormatLite::TYPE_MESSAGE:
1320 0 : GOOGLE_LOG(FATAL) << "Non-primitive types can't be packed.";
1321 0 : break;
1322 : }
1323 : } else {
1324 0 : switch (real_type(type)) {
1325 : #define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \
1326 : case WireFormatLite::TYPE_##UPPERCASE: \
1327 : for (int i = 0; i < repeated_##LOWERCASE##_value->size(); i++) { \
1328 : WireFormatLite::Write##CAMELCASE(number, \
1329 : repeated_##LOWERCASE##_value->Get(i), output); \
1330 : } \
1331 : break
1332 :
1333 0 : HANDLE_TYPE( INT32, Int32, int32);
1334 0 : HANDLE_TYPE( INT64, Int64, int64);
1335 0 : HANDLE_TYPE( UINT32, UInt32, uint32);
1336 0 : HANDLE_TYPE( UINT64, UInt64, uint64);
1337 0 : HANDLE_TYPE( SINT32, SInt32, int32);
1338 0 : HANDLE_TYPE( SINT64, SInt64, int64);
1339 0 : HANDLE_TYPE( FIXED32, Fixed32, uint32);
1340 0 : HANDLE_TYPE( FIXED64, Fixed64, uint64);
1341 0 : HANDLE_TYPE(SFIXED32, SFixed32, int32);
1342 0 : HANDLE_TYPE(SFIXED64, SFixed64, int64);
1343 0 : HANDLE_TYPE( FLOAT, Float, float);
1344 0 : HANDLE_TYPE( DOUBLE, Double, double);
1345 0 : HANDLE_TYPE( BOOL, Bool, bool);
1346 0 : HANDLE_TYPE( STRING, String, string);
1347 0 : HANDLE_TYPE( BYTES, Bytes, string);
1348 0 : HANDLE_TYPE( ENUM, Enum, enum);
1349 0 : HANDLE_TYPE( GROUP, Group, message);
1350 0 : HANDLE_TYPE( MESSAGE, Message, message);
1351 : #undef HANDLE_TYPE
1352 : }
1353 : }
1354 0 : } else if (!is_cleared) {
1355 0 : switch (real_type(type)) {
1356 : #define HANDLE_TYPE(UPPERCASE, CAMELCASE, VALUE) \
1357 : case WireFormatLite::TYPE_##UPPERCASE: \
1358 : WireFormatLite::Write##CAMELCASE(number, VALUE, output); \
1359 : break
1360 :
1361 0 : HANDLE_TYPE( INT32, Int32, int32_value);
1362 0 : HANDLE_TYPE( INT64, Int64, int64_value);
1363 0 : HANDLE_TYPE( UINT32, UInt32, uint32_value);
1364 0 : HANDLE_TYPE( UINT64, UInt64, uint64_value);
1365 0 : HANDLE_TYPE( SINT32, SInt32, int32_value);
1366 0 : HANDLE_TYPE( SINT64, SInt64, int64_value);
1367 0 : HANDLE_TYPE( FIXED32, Fixed32, uint32_value);
1368 0 : HANDLE_TYPE( FIXED64, Fixed64, uint64_value);
1369 0 : HANDLE_TYPE(SFIXED32, SFixed32, int32_value);
1370 0 : HANDLE_TYPE(SFIXED64, SFixed64, int64_value);
1371 0 : HANDLE_TYPE( FLOAT, Float, float_value);
1372 0 : HANDLE_TYPE( DOUBLE, Double, double_value);
1373 0 : HANDLE_TYPE( BOOL, Bool, bool_value);
1374 0 : HANDLE_TYPE( STRING, String, *string_value);
1375 0 : HANDLE_TYPE( BYTES, Bytes, *string_value);
1376 0 : HANDLE_TYPE( ENUM, Enum, enum_value);
1377 0 : HANDLE_TYPE( GROUP, Group, *message_value);
1378 : #undef HANDLE_TYPE
1379 : case WireFormatLite::TYPE_MESSAGE:
1380 0 : if (is_lazy) {
1381 0 : lazymessage_value->WriteMessage(number, output);
1382 : } else {
1383 0 : WireFormatLite::WriteMessage(number, *message_value, output);
1384 : }
1385 0 : break;
1386 : }
1387 : }
1388 : }
1389 :
1390 0 : int ExtensionSet::Extension::ByteSize(int number) const {
1391 0 : int result = 0;
1392 :
1393 0 : if (is_repeated) {
1394 0 : if (is_packed) {
1395 0 : switch (real_type(type)) {
1396 : #define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \
1397 : case WireFormatLite::TYPE_##UPPERCASE: \
1398 : for (int i = 0; i < repeated_##LOWERCASE##_value->size(); i++) { \
1399 : result += WireFormatLite::CAMELCASE##Size( \
1400 : repeated_##LOWERCASE##_value->Get(i)); \
1401 : } \
1402 : break
1403 :
1404 0 : HANDLE_TYPE( INT32, Int32, int32);
1405 0 : HANDLE_TYPE( INT64, Int64, int64);
1406 0 : HANDLE_TYPE( UINT32, UInt32, uint32);
1407 0 : HANDLE_TYPE( UINT64, UInt64, uint64);
1408 0 : HANDLE_TYPE( SINT32, SInt32, int32);
1409 0 : HANDLE_TYPE( SINT64, SInt64, int64);
1410 0 : HANDLE_TYPE( ENUM, Enum, enum);
1411 : #undef HANDLE_TYPE
1412 :
1413 : // Stuff with fixed size.
1414 : #define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \
1415 : case WireFormatLite::TYPE_##UPPERCASE: \
1416 : result += WireFormatLite::k##CAMELCASE##Size * \
1417 : repeated_##LOWERCASE##_value->size(); \
1418 : break
1419 0 : HANDLE_TYPE( FIXED32, Fixed32, uint32);
1420 0 : HANDLE_TYPE( FIXED64, Fixed64, uint64);
1421 0 : HANDLE_TYPE(SFIXED32, SFixed32, int32);
1422 0 : HANDLE_TYPE(SFIXED64, SFixed64, int64);
1423 0 : HANDLE_TYPE( FLOAT, Float, float);
1424 0 : HANDLE_TYPE( DOUBLE, Double, double);
1425 0 : HANDLE_TYPE( BOOL, Bool, bool);
1426 : #undef HANDLE_TYPE
1427 :
1428 : case WireFormatLite::TYPE_STRING:
1429 : case WireFormatLite::TYPE_BYTES:
1430 : case WireFormatLite::TYPE_GROUP:
1431 : case WireFormatLite::TYPE_MESSAGE:
1432 0 : GOOGLE_LOG(FATAL) << "Non-primitive types can't be packed.";
1433 0 : break;
1434 : }
1435 :
1436 0 : cached_size = result;
1437 0 : if (result > 0) {
1438 0 : result += io::CodedOutputStream::VarintSize32(result);
1439 0 : result += io::CodedOutputStream::VarintSize32(
1440 : WireFormatLite::MakeTag(number,
1441 : WireFormatLite::WIRETYPE_LENGTH_DELIMITED));
1442 : }
1443 : } else {
1444 0 : int tag_size = WireFormatLite::TagSize(number, real_type(type));
1445 :
1446 0 : switch (real_type(type)) {
1447 : #define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \
1448 : case WireFormatLite::TYPE_##UPPERCASE: \
1449 : result += tag_size * repeated_##LOWERCASE##_value->size(); \
1450 : for (int i = 0; i < repeated_##LOWERCASE##_value->size(); i++) { \
1451 : result += WireFormatLite::CAMELCASE##Size( \
1452 : repeated_##LOWERCASE##_value->Get(i)); \
1453 : } \
1454 : break
1455 :
1456 0 : HANDLE_TYPE( INT32, Int32, int32);
1457 0 : HANDLE_TYPE( INT64, Int64, int64);
1458 0 : HANDLE_TYPE( UINT32, UInt32, uint32);
1459 0 : HANDLE_TYPE( UINT64, UInt64, uint64);
1460 0 : HANDLE_TYPE( SINT32, SInt32, int32);
1461 0 : HANDLE_TYPE( SINT64, SInt64, int64);
1462 0 : HANDLE_TYPE( STRING, String, string);
1463 0 : HANDLE_TYPE( BYTES, Bytes, string);
1464 0 : HANDLE_TYPE( ENUM, Enum, enum);
1465 0 : HANDLE_TYPE( GROUP, Group, message);
1466 0 : HANDLE_TYPE( MESSAGE, Message, message);
1467 : #undef HANDLE_TYPE
1468 :
1469 : // Stuff with fixed size.
1470 : #define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \
1471 : case WireFormatLite::TYPE_##UPPERCASE: \
1472 : result += (tag_size + WireFormatLite::k##CAMELCASE##Size) * \
1473 : repeated_##LOWERCASE##_value->size(); \
1474 : break
1475 0 : HANDLE_TYPE( FIXED32, Fixed32, uint32);
1476 0 : HANDLE_TYPE( FIXED64, Fixed64, uint64);
1477 0 : HANDLE_TYPE(SFIXED32, SFixed32, int32);
1478 0 : HANDLE_TYPE(SFIXED64, SFixed64, int64);
1479 0 : HANDLE_TYPE( FLOAT, Float, float);
1480 0 : HANDLE_TYPE( DOUBLE, Double, double);
1481 0 : HANDLE_TYPE( BOOL, Bool, bool);
1482 : #undef HANDLE_TYPE
1483 : }
1484 : }
1485 0 : } else if (!is_cleared) {
1486 0 : result += WireFormatLite::TagSize(number, real_type(type));
1487 0 : switch (real_type(type)) {
1488 : #define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \
1489 : case WireFormatLite::TYPE_##UPPERCASE: \
1490 : result += WireFormatLite::CAMELCASE##Size(LOWERCASE); \
1491 : break
1492 :
1493 0 : HANDLE_TYPE( INT32, Int32, int32_value);
1494 0 : HANDLE_TYPE( INT64, Int64, int64_value);
1495 0 : HANDLE_TYPE( UINT32, UInt32, uint32_value);
1496 0 : HANDLE_TYPE( UINT64, UInt64, uint64_value);
1497 0 : HANDLE_TYPE( SINT32, SInt32, int32_value);
1498 0 : HANDLE_TYPE( SINT64, SInt64, int64_value);
1499 0 : HANDLE_TYPE( STRING, String, *string_value);
1500 0 : HANDLE_TYPE( BYTES, Bytes, *string_value);
1501 0 : HANDLE_TYPE( ENUM, Enum, enum_value);
1502 0 : HANDLE_TYPE( GROUP, Group, *message_value);
1503 : #undef HANDLE_TYPE
1504 : case WireFormatLite::TYPE_MESSAGE: {
1505 0 : if (is_lazy) {
1506 0 : int size = lazymessage_value->ByteSize();
1507 0 : result += io::CodedOutputStream::VarintSize32(size) + size;
1508 : } else {
1509 0 : result += WireFormatLite::MessageSize(*message_value);
1510 : }
1511 0 : break;
1512 : }
1513 :
1514 : // Stuff with fixed size.
1515 : #define HANDLE_TYPE(UPPERCASE, CAMELCASE) \
1516 : case WireFormatLite::TYPE_##UPPERCASE: \
1517 : result += WireFormatLite::k##CAMELCASE##Size; \
1518 : break
1519 0 : HANDLE_TYPE( FIXED32, Fixed32);
1520 0 : HANDLE_TYPE( FIXED64, Fixed64);
1521 0 : HANDLE_TYPE(SFIXED32, SFixed32);
1522 0 : HANDLE_TYPE(SFIXED64, SFixed64);
1523 0 : HANDLE_TYPE( FLOAT, Float);
1524 0 : HANDLE_TYPE( DOUBLE, Double);
1525 0 : HANDLE_TYPE( BOOL, Bool);
1526 : #undef HANDLE_TYPE
1527 : }
1528 : }
1529 :
1530 0 : return result;
1531 : }
1532 :
1533 0 : int ExtensionSet::Extension::GetSize() const {
1534 0 : GOOGLE_DCHECK(is_repeated);
1535 0 : switch (cpp_type(type)) {
1536 : #define HANDLE_TYPE(UPPERCASE, LOWERCASE) \
1537 : case WireFormatLite::CPPTYPE_##UPPERCASE: \
1538 : return repeated_##LOWERCASE##_value->size()
1539 :
1540 0 : HANDLE_TYPE( INT32, int32);
1541 0 : HANDLE_TYPE( INT64, int64);
1542 0 : HANDLE_TYPE( UINT32, uint32);
1543 0 : HANDLE_TYPE( UINT64, uint64);
1544 0 : HANDLE_TYPE( FLOAT, float);
1545 0 : HANDLE_TYPE( DOUBLE, double);
1546 0 : HANDLE_TYPE( BOOL, bool);
1547 0 : HANDLE_TYPE( ENUM, enum);
1548 0 : HANDLE_TYPE( STRING, string);
1549 0 : HANDLE_TYPE(MESSAGE, message);
1550 : #undef HANDLE_TYPE
1551 : }
1552 :
1553 0 : GOOGLE_LOG(FATAL) << "Can't get here.";
1554 0 : return 0;
1555 : }
1556 :
1557 0 : void ExtensionSet::Extension::Free() {
1558 0 : if (is_repeated) {
1559 0 : switch (cpp_type(type)) {
1560 : #define HANDLE_TYPE(UPPERCASE, LOWERCASE) \
1561 : case WireFormatLite::CPPTYPE_##UPPERCASE: \
1562 : delete repeated_##LOWERCASE##_value; \
1563 : break
1564 :
1565 0 : HANDLE_TYPE( INT32, int32);
1566 0 : HANDLE_TYPE( INT64, int64);
1567 0 : HANDLE_TYPE( UINT32, uint32);
1568 0 : HANDLE_TYPE( UINT64, uint64);
1569 0 : HANDLE_TYPE( FLOAT, float);
1570 0 : HANDLE_TYPE( DOUBLE, double);
1571 0 : HANDLE_TYPE( BOOL, bool);
1572 0 : HANDLE_TYPE( ENUM, enum);
1573 0 : HANDLE_TYPE( STRING, string);
1574 0 : HANDLE_TYPE(MESSAGE, message);
1575 : #undef HANDLE_TYPE
1576 : }
1577 : } else {
1578 0 : switch (cpp_type(type)) {
1579 : case WireFormatLite::CPPTYPE_STRING:
1580 0 : delete string_value;
1581 0 : break;
1582 : case WireFormatLite::CPPTYPE_MESSAGE:
1583 0 : if (is_lazy) {
1584 0 : delete lazymessage_value;
1585 : } else {
1586 0 : delete message_value;
1587 : }
1588 0 : break;
1589 : default:
1590 0 : break;
1591 : }
1592 : }
1593 0 : }
1594 :
1595 : // Defined in extension_set_heavy.cc.
1596 : // int ExtensionSet::Extension::SpaceUsedExcludingSelf() const
1597 :
1598 : // ==================================================================
1599 : // Default repeated field instances for iterator-compatible accessors
1600 :
1601 : const RepeatedStringTypeTraits::RepeatedFieldType*
1602 : RepeatedStringTypeTraits::default_repeated_field_ = NULL;
1603 :
1604 : const RepeatedMessageGenericTypeTraits::RepeatedFieldType*
1605 : RepeatedMessageGenericTypeTraits::default_repeated_field_ = NULL;
1606 :
1607 : #define PROTOBUF_DEFINE_DEFAULT_REPEATED(TYPE) \
1608 : const RepeatedField<TYPE>* \
1609 : RepeatedPrimitiveGenericTypeTraits::default_repeated_field_##TYPE##_ = NULL;
1610 :
1611 : PROTOBUF_DEFINE_DEFAULT_REPEATED(int32)
1612 : PROTOBUF_DEFINE_DEFAULT_REPEATED(int64)
1613 : PROTOBUF_DEFINE_DEFAULT_REPEATED(uint32)
1614 : PROTOBUF_DEFINE_DEFAULT_REPEATED(uint64)
1615 : PROTOBUF_DEFINE_DEFAULT_REPEATED(double)
1616 : PROTOBUF_DEFINE_DEFAULT_REPEATED(float)
1617 : PROTOBUF_DEFINE_DEFAULT_REPEATED(bool)
1618 :
1619 : #undef PROTOBUF_DEFINE_DEFAULT_REPEATED
1620 :
1621 : struct StaticDefaultRepeatedFieldsInitializer {
1622 3 : StaticDefaultRepeatedFieldsInitializer() {
1623 3 : InitializeDefaultRepeatedFields();
1624 3 : OnShutdown(&DestroyDefaultRepeatedFields);
1625 3 : }
1626 3 : } static_repeated_fields_initializer;
1627 :
1628 3 : void InitializeDefaultRepeatedFields() {
1629 3 : RepeatedStringTypeTraits::default_repeated_field_ =
1630 3 : new RepeatedStringTypeTraits::RepeatedFieldType;
1631 3 : RepeatedMessageGenericTypeTraits::default_repeated_field_ =
1632 3 : new RepeatedMessageGenericTypeTraits::RepeatedFieldType;
1633 3 : RepeatedPrimitiveGenericTypeTraits::default_repeated_field_int32_ =
1634 3 : new RepeatedField<int32>;
1635 3 : RepeatedPrimitiveGenericTypeTraits::default_repeated_field_int64_ =
1636 3 : new RepeatedField<int64>;
1637 3 : RepeatedPrimitiveGenericTypeTraits::default_repeated_field_uint32_ =
1638 3 : new RepeatedField<uint32>;
1639 3 : RepeatedPrimitiveGenericTypeTraits::default_repeated_field_uint64_ =
1640 3 : new RepeatedField<uint64>;
1641 3 : RepeatedPrimitiveGenericTypeTraits::default_repeated_field_double_ =
1642 3 : new RepeatedField<double>;
1643 3 : RepeatedPrimitiveGenericTypeTraits::default_repeated_field_float_ =
1644 3 : new RepeatedField<float>;
1645 3 : RepeatedPrimitiveGenericTypeTraits::default_repeated_field_bool_ =
1646 3 : new RepeatedField<bool>;
1647 3 : }
1648 :
1649 0 : void DestroyDefaultRepeatedFields() {
1650 0 : delete RepeatedStringTypeTraits::default_repeated_field_;
1651 0 : delete RepeatedMessageGenericTypeTraits::default_repeated_field_;
1652 0 : delete RepeatedPrimitiveGenericTypeTraits::default_repeated_field_int32_;
1653 0 : delete RepeatedPrimitiveGenericTypeTraits::default_repeated_field_int64_;
1654 0 : delete RepeatedPrimitiveGenericTypeTraits::default_repeated_field_uint32_;
1655 0 : delete RepeatedPrimitiveGenericTypeTraits::default_repeated_field_uint64_;
1656 0 : delete RepeatedPrimitiveGenericTypeTraits::default_repeated_field_double_;
1657 0 : delete RepeatedPrimitiveGenericTypeTraits::default_repeated_field_float_;
1658 0 : delete RepeatedPrimitiveGenericTypeTraits::default_repeated_field_bool_;
1659 0 : }
1660 :
1661 : } // namespace internal
1662 : } // namespace protobuf
1663 : } // namespace google
|
