OLD | NEW |
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 58 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
69 return false; | 69 return false; |
70 | 70 |
71 // Do not add a default statement. Let the compiler complain when someone | 71 // Do not add a default statement. Let the compiler complain when someone |
72 // adds a new wire type. | 72 // adds a new wire type. |
73 } | 73 } |
74 GOOGLE_LOG(FATAL) << "can't reach here."; | 74 GOOGLE_LOG(FATAL) << "can't reach here."; |
75 return false; | 75 return false; |
76 } | 76 } |
77 | 77 |
78 // Registry stuff. | 78 // Registry stuff. |
79 typedef hash_map<std::pair<const MessageLite*, int>, | 79 typedef hash_map<pair<const MessageLite*, int>, |
80 ExtensionInfo> ExtensionRegistry; | 80 ExtensionInfo> ExtensionRegistry; |
81 ExtensionRegistry* registry_ = NULL; | 81 ExtensionRegistry* registry_ = NULL; |
82 GOOGLE_PROTOBUF_DECLARE_ONCE(registry_init_); | 82 GOOGLE_PROTOBUF_DECLARE_ONCE(registry_init_); |
83 | 83 |
84 void DeleteRegistry() { | 84 void DeleteRegistry() { |
85 delete registry_; | 85 delete registry_; |
86 registry_ = NULL; | 86 registry_ = NULL; |
87 } | 87 } |
88 | 88 |
89 void InitRegistry() { | 89 void InitRegistry() { |
(...skipping 80 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
170 type == WireFormatLite::TYPE_GROUP); | 170 type == WireFormatLite::TYPE_GROUP); |
171 ExtensionInfo info(type, is_repeated, is_packed); | 171 ExtensionInfo info(type, is_repeated, is_packed); |
172 info.message_prototype = prototype; | 172 info.message_prototype = prototype; |
173 Register(containing_type, number, info); | 173 Register(containing_type, number, info); |
174 } | 174 } |
175 | 175 |
176 | 176 |
177 // =================================================================== | 177 // =================================================================== |
178 // Constructors and basic methods. | 178 // Constructors and basic methods. |
179 | 179 |
180 ExtensionSet::ExtensionSet(::google::protobuf::Arena* arena) | 180 ExtensionSet::ExtensionSet(::google::protobuf::Arena* arena) : arena_(arena) { |
181 : arena_(arena) { | |
182 if (arena_ != NULL) { | 181 if (arena_ != NULL) { |
183 arena_->OwnDestructor(&extensions_); | 182 arena_->OwnDestructor(&extensions_); |
184 } | 183 } |
185 } | 184 } |
186 | 185 |
187 ExtensionSet::ExtensionSet() : arena_(NULL) {} | 186 ExtensionSet::ExtensionSet() : arena_(NULL) {} |
188 | 187 |
189 ExtensionSet::~ExtensionSet() { | 188 ExtensionSet::~ExtensionSet() { |
190 // Deletes all allocated extensions. | 189 // Deletes all allocated extensions. |
191 if (arena_ == NULL) { | 190 if (arena_ == NULL) { |
192 for (ExtensionMap::iterator iter = extensions_.begin(); | 191 for (map<int, Extension>::iterator iter = extensions_.begin(); |
193 iter != extensions_.end(); ++iter) { | 192 iter != extensions_.end(); ++iter) { |
194 iter->second.Free(); | 193 iter->second.Free(); |
195 } | 194 } |
196 } | 195 } |
197 } | 196 } |
198 | 197 |
199 // Defined in extension_set_heavy.cc. | 198 // Defined in extension_set_heavy.cc. |
200 // void ExtensionSet::AppendToList(const Descriptor* containing_type, | 199 // void ExtensionSet::AppendToList(const Descriptor* containing_type, |
201 // const DescriptorPool* pool, | 200 // const DescriptorPool* pool, |
202 // vector<const FieldDescriptor*>* output) const | 201 // vector<const FieldDescriptor*>* output) const |
203 | 202 |
204 bool ExtensionSet::Has(int number) const { | 203 bool ExtensionSet::Has(int number) const { |
205 ExtensionMap::const_iterator iter = extensions_.find(number); | 204 map<int, Extension>::const_iterator iter = extensions_.find(number); |
206 if (iter == extensions_.end()) return false; | 205 if (iter == extensions_.end()) return false; |
207 GOOGLE_DCHECK(!iter->second.is_repeated); | 206 GOOGLE_DCHECK(!iter->second.is_repeated); |
208 return !iter->second.is_cleared; | 207 return !iter->second.is_cleared; |
209 } | 208 } |
210 | 209 |
211 int ExtensionSet::NumExtensions() const { | 210 int ExtensionSet::NumExtensions() const { |
212 int result = 0; | 211 int result = 0; |
213 for (ExtensionMap::const_iterator iter = extensions_.begin(); | 212 for (map<int, Extension>::const_iterator iter = extensions_.begin(); |
214 iter != extensions_.end(); ++iter) { | 213 iter != extensions_.end(); ++iter) { |
215 if (!iter->second.is_cleared) { | 214 if (!iter->second.is_cleared) { |
216 ++result; | 215 ++result; |
217 } | 216 } |
218 } | 217 } |
219 return result; | 218 return result; |
220 } | 219 } |
221 | 220 |
222 int ExtensionSet::ExtensionSize(int number) const { | 221 int ExtensionSet::ExtensionSize(int number) const { |
223 ExtensionMap::const_iterator iter = extensions_.find(number); | 222 map<int, Extension>::const_iterator iter = extensions_.find(number); |
224 if (iter == extensions_.end()) return false; | 223 if (iter == extensions_.end()) return false; |
225 return iter->second.GetSize(); | 224 return iter->second.GetSize(); |
226 } | 225 } |
227 | 226 |
228 FieldType ExtensionSet::ExtensionType(int number) const { | 227 FieldType ExtensionSet::ExtensionType(int number) const { |
229 ExtensionMap::const_iterator iter = extensions_.find(number); | 228 map<int, Extension>::const_iterator iter = extensions_.find(number); |
230 if (iter == extensions_.end()) { | 229 if (iter == extensions_.end()) { |
231 GOOGLE_LOG(DFATAL) << "Don't lookup extension types if they aren't present (
1). "; | 230 GOOGLE_LOG(DFATAL) << "Don't lookup extension types if they aren't present (
1). "; |
232 return 0; | 231 return 0; |
233 } | 232 } |
234 if (iter->second.is_cleared) { | 233 if (iter->second.is_cleared) { |
235 GOOGLE_LOG(DFATAL) << "Don't lookup extension types if they aren't present (
2). "; | 234 GOOGLE_LOG(DFATAL) << "Don't lookup extension types if they aren't present (
2). "; |
236 } | 235 } |
237 return iter->second.type; | 236 return iter->second.type; |
238 } | 237 } |
239 | 238 |
240 void ExtensionSet::ClearExtension(int number) { | 239 void ExtensionSet::ClearExtension(int number) { |
241 ExtensionMap::iterator iter = extensions_.find(number); | 240 map<int, Extension>::iterator iter = extensions_.find(number); |
242 if (iter == extensions_.end()) return; | 241 if (iter == extensions_.end()) return; |
243 iter->second.Clear(); | 242 iter->second.Clear(); |
244 } | 243 } |
245 | 244 |
246 // =================================================================== | 245 // =================================================================== |
247 // Field accessors | 246 // Field accessors |
248 | 247 |
249 namespace { | 248 namespace { |
250 | 249 |
251 enum Cardinality { | 250 enum Cardinality { |
252 REPEATED, | 251 REPEATED, |
253 OPTIONAL | 252 OPTIONAL |
254 }; | 253 }; |
255 | 254 |
256 } // namespace | 255 } // namespace |
257 | 256 |
258 #define GOOGLE_DCHECK_TYPE(EXTENSION, LABEL, CPPTYPE)
\ | 257 #define GOOGLE_DCHECK_TYPE(EXTENSION, LABEL, CPPTYPE)
\ |
259 GOOGLE_DCHECK_EQ((EXTENSION).is_repeated ? REPEATED : OPTIONAL, LABEL);
\ | 258 GOOGLE_DCHECK_EQ((EXTENSION).is_repeated ? REPEATED : OPTIONAL, LABEL);
\ |
260 GOOGLE_DCHECK_EQ(cpp_type((EXTENSION).type), WireFormatLite::CPPTYPE_##CPPTYPE
) | 259 GOOGLE_DCHECK_EQ(cpp_type((EXTENSION).type), WireFormatLite::CPPTYPE_##CPPTYPE
) |
261 | 260 |
262 // ------------------------------------------------------------------- | 261 // ------------------------------------------------------------------- |
263 // Primitives | 262 // Primitives |
264 | 263 |
265 #define PRIMITIVE_ACCESSORS(UPPERCASE, LOWERCASE, CAMELCASE) \ | 264 #define PRIMITIVE_ACCESSORS(UPPERCASE, LOWERCASE, CAMELCASE) \ |
266 \ | 265 \ |
267 LOWERCASE ExtensionSet::Get##CAMELCASE(int number, \ | 266 LOWERCASE ExtensionSet::Get##CAMELCASE(int number, \ |
268 LOWERCASE default_value) const { \ | 267 LOWERCASE default_value) const { \ |
269 ExtensionMap::const_iterator iter = extensions_.find(number); \ | 268 map<int, Extension>::const_iterator iter = extensions_.find(number); \ |
270 if (iter == extensions_.end() || iter->second.is_cleared) { \ | 269 if (iter == extensions_.end() || iter->second.is_cleared) { \ |
271 return default_value; \ | 270 return default_value; \ |
272 } else { \ | 271 } else { \ |
273 GOOGLE_DCHECK_TYPE(iter->second, OPTIONAL, UPPERCASE);
\ | 272 GOOGLE_DCHECK_TYPE(iter->second, OPTIONAL, UPPERCASE);
\ |
274 return iter->second.LOWERCASE##_value; \ | 273 return iter->second.LOWERCASE##_value; \ |
275 } \ | 274 } \ |
276 } \ | 275 } \ |
277 \ | 276 \ |
278 void ExtensionSet::Set##CAMELCASE(int number, FieldType type, \ | 277 void ExtensionSet::Set##CAMELCASE(int number, FieldType type, \ |
279 LOWERCASE value, \ | 278 LOWERCASE value, \ |
280 const FieldDescriptor* descriptor) { \ | 279 const FieldDescriptor* descriptor) { \ |
281 Extension* extension; \ | 280 Extension* extension; \ |
282 if (MaybeNewExtension(number, descriptor, &extension)) { \ | 281 if (MaybeNewExtension(number, descriptor, &extension)) { \ |
283 extension->type = type; \ | 282 extension->type = type; \ |
284 GOOGLE_DCHECK_EQ(cpp_type(extension->type), WireFormatLite::CPPTYPE_##UPPERC
ASE); \ | 283 GOOGLE_DCHECK_EQ(cpp_type(extension->type), WireFormatLite::CPPTYPE_##UPPERC
ASE); \ |
285 extension->is_repeated = false; \ | 284 extension->is_repeated = false; \ |
286 } else { \ | 285 } else { \ |
287 GOOGLE_DCHECK_TYPE(*extension, OPTIONAL, UPPERCASE);
\ | 286 GOOGLE_DCHECK_TYPE(*extension, OPTIONAL, UPPERCASE);
\ |
288 } \ | 287 } \ |
289 extension->is_cleared = false; \ | 288 extension->is_cleared = false; \ |
290 extension->LOWERCASE##_value = value; \ | 289 extension->LOWERCASE##_value = value; \ |
291 } \ | 290 } \ |
292 \ | 291 \ |
293 LOWERCASE ExtensionSet::GetRepeated##CAMELCASE(int number, int index) const { \ | 292 LOWERCASE ExtensionSet::GetRepeated##CAMELCASE(int number, int index) const { \ |
294 ExtensionMap::const_iterator iter = extensions_.find(number); \ | 293 map<int, Extension>::const_iterator iter = extensions_.find(number); \ |
295 GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empt
y)."; \ | 294 GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empt
y)."; \ |
296 GOOGLE_DCHECK_TYPE(iter->second, REPEATED, UPPERCASE);
\ | 295 GOOGLE_DCHECK_TYPE(iter->second, REPEATED, UPPERCASE);
\ |
297 return iter->second.repeated_##LOWERCASE##_value->Get(index); \ | 296 return iter->second.repeated_##LOWERCASE##_value->Get(index); \ |
298 } \ | 297 } \ |
299 \ | 298 \ |
300 void ExtensionSet::SetRepeated##CAMELCASE( \ | 299 void ExtensionSet::SetRepeated##CAMELCASE( \ |
301 int number, int index, LOWERCASE value) { \ | 300 int number, int index, LOWERCASE value) { \ |
302 ExtensionMap::iterator iter = extensions_.find(number); \ | 301 map<int, Extension>::iterator iter = extensions_.find(number); \ |
303 GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empt
y)."; \ | 302 GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empt
y)."; \ |
304 GOOGLE_DCHECK_TYPE(iter->second, REPEATED, UPPERCASE);
\ | 303 GOOGLE_DCHECK_TYPE(iter->second, REPEATED, UPPERCASE);
\ |
305 iter->second.repeated_##LOWERCASE##_value->Set(index, value); \ | 304 iter->second.repeated_##LOWERCASE##_value->Set(index, value); \ |
306 } \ | 305 } \ |
307 \ | 306 \ |
308 void ExtensionSet::Add##CAMELCASE(int number, FieldType type, \ | 307 void ExtensionSet::Add##CAMELCASE(int number, FieldType type, \ |
309 bool packed, LOWERCASE value, \ | 308 bool packed, LOWERCASE value, \ |
310 const FieldDescriptor* descriptor) { \ | 309 const FieldDescriptor* descriptor) { \ |
311 Extension* extension; \ | 310 Extension* extension; \ |
312 if (MaybeNewExtension(number, descriptor, &extension)) { \ | 311 if (MaybeNewExtension(number, descriptor, &extension)) { \ |
(...skipping 15 matching lines...) Expand all Loading... |
328 PRIMITIVE_ACCESSORS(UINT32, uint32, UInt32) | 327 PRIMITIVE_ACCESSORS(UINT32, uint32, UInt32) |
329 PRIMITIVE_ACCESSORS(UINT64, uint64, UInt64) | 328 PRIMITIVE_ACCESSORS(UINT64, uint64, UInt64) |
330 PRIMITIVE_ACCESSORS( FLOAT, float, Float) | 329 PRIMITIVE_ACCESSORS( FLOAT, float, Float) |
331 PRIMITIVE_ACCESSORS(DOUBLE, double, Double) | 330 PRIMITIVE_ACCESSORS(DOUBLE, double, Double) |
332 PRIMITIVE_ACCESSORS( BOOL, bool, Bool) | 331 PRIMITIVE_ACCESSORS( BOOL, bool, Bool) |
333 | 332 |
334 #undef PRIMITIVE_ACCESSORS | 333 #undef PRIMITIVE_ACCESSORS |
335 | 334 |
336 const void* ExtensionSet::GetRawRepeatedField(int number, | 335 const void* ExtensionSet::GetRawRepeatedField(int number, |
337 const void* default_value) const { | 336 const void* default_value) const { |
338 ExtensionMap::const_iterator iter = extensions_.find(number); | 337 map<int, Extension>::const_iterator iter = extensions_.find(number); |
339 if (iter == extensions_.end()) { | 338 if (iter == extensions_.end()) { |
340 return default_value; | 339 return default_value; |
341 } | 340 } |
342 // We assume that all the RepeatedField<>* pointers have the same | 341 // We assume that all the RepeatedField<>* pointers have the same |
343 // size and alignment within the anonymous union in Extension. | 342 // size and alignment within the anonymous union in Extension. |
344 return iter->second.repeated_int32_value; | 343 return iter->second.repeated_int32_value; |
345 } | 344 } |
346 | 345 |
347 void* ExtensionSet::MutableRawRepeatedField(int number, FieldType field_type, | 346 void* ExtensionSet::MutableRawRepeatedField(int number, FieldType field_type, |
348 bool packed, | 347 bool packed, |
(...skipping 53 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
402 } | 401 } |
403 | 402 |
404 // We assume that all the RepeatedField<>* pointers have the same | 403 // We assume that all the RepeatedField<>* pointers have the same |
405 // size and alignment within the anonymous union in Extension. | 404 // size and alignment within the anonymous union in Extension. |
406 return extension->repeated_int32_value; | 405 return extension->repeated_int32_value; |
407 } | 406 } |
408 | 407 |
409 // Compatible version using old call signature. Does not create extensions when | 408 // Compatible version using old call signature. Does not create extensions when |
410 // the don't already exist; instead, just GOOGLE_CHECK-fails. | 409 // the don't already exist; instead, just GOOGLE_CHECK-fails. |
411 void* ExtensionSet::MutableRawRepeatedField(int number) { | 410 void* ExtensionSet::MutableRawRepeatedField(int number) { |
412 ExtensionMap::iterator iter = extensions_.find(number); | 411 map<int, Extension>::iterator iter = extensions_.find(number); |
413 GOOGLE_CHECK(iter == extensions_.end()) << "Extension not found."; | 412 GOOGLE_CHECK(iter == extensions_.end()) << "Extension not found."; |
414 // We assume that all the RepeatedField<>* pointers have the same | 413 // We assume that all the RepeatedField<>* pointers have the same |
415 // size and alignment within the anonymous union in Extension. | 414 // size and alignment within the anonymous union in Extension. |
416 return iter->second.repeated_int32_value; | 415 return iter->second.repeated_int32_value; |
417 } | 416 } |
418 | 417 |
419 | 418 |
420 // ------------------------------------------------------------------- | 419 // ------------------------------------------------------------------- |
421 // Enums | 420 // Enums |
422 | 421 |
423 int ExtensionSet::GetEnum(int number, int default_value) const { | 422 int ExtensionSet::GetEnum(int number, int default_value) const { |
424 ExtensionMap::const_iterator iter = extensions_.find(number); | 423 map<int, Extension>::const_iterator iter = extensions_.find(number); |
425 if (iter == extensions_.end() || iter->second.is_cleared) { | 424 if (iter == extensions_.end() || iter->second.is_cleared) { |
426 // Not present. Return the default value. | 425 // Not present. Return the default value. |
427 return default_value; | 426 return default_value; |
428 } else { | 427 } else { |
429 GOOGLE_DCHECK_TYPE(iter->second, OPTIONAL, ENUM); | 428 GOOGLE_DCHECK_TYPE(iter->second, OPTIONAL, ENUM); |
430 return iter->second.enum_value; | 429 return iter->second.enum_value; |
431 } | 430 } |
432 } | 431 } |
433 | 432 |
434 void ExtensionSet::SetEnum(int number, FieldType type, int value, | 433 void ExtensionSet::SetEnum(int number, FieldType type, int value, |
435 const FieldDescriptor* descriptor) { | 434 const FieldDescriptor* descriptor) { |
436 Extension* extension; | 435 Extension* extension; |
437 if (MaybeNewExtension(number, descriptor, &extension)) { | 436 if (MaybeNewExtension(number, descriptor, &extension)) { |
438 extension->type = type; | 437 extension->type = type; |
439 GOOGLE_DCHECK_EQ(cpp_type(extension->type), WireFormatLite::CPPTYPE_ENUM); | 438 GOOGLE_DCHECK_EQ(cpp_type(extension->type), WireFormatLite::CPPTYPE_ENUM); |
440 extension->is_repeated = false; | 439 extension->is_repeated = false; |
441 } else { | 440 } else { |
442 GOOGLE_DCHECK_TYPE(*extension, OPTIONAL, ENUM); | 441 GOOGLE_DCHECK_TYPE(*extension, OPTIONAL, ENUM); |
443 } | 442 } |
444 extension->is_cleared = false; | 443 extension->is_cleared = false; |
445 extension->enum_value = value; | 444 extension->enum_value = value; |
446 } | 445 } |
447 | 446 |
448 int ExtensionSet::GetRepeatedEnum(int number, int index) const { | 447 int ExtensionSet::GetRepeatedEnum(int number, int index) const { |
449 ExtensionMap::const_iterator iter = extensions_.find(number); | 448 map<int, Extension>::const_iterator iter = extensions_.find(number); |
450 GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empt
y)."; | 449 GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empt
y)."; |
451 GOOGLE_DCHECK_TYPE(iter->second, REPEATED, ENUM); | 450 GOOGLE_DCHECK_TYPE(iter->second, REPEATED, ENUM); |
452 return iter->second.repeated_enum_value->Get(index); | 451 return iter->second.repeated_enum_value->Get(index); |
453 } | 452 } |
454 | 453 |
455 void ExtensionSet::SetRepeatedEnum(int number, int index, int value) { | 454 void ExtensionSet::SetRepeatedEnum(int number, int index, int value) { |
456 ExtensionMap::iterator iter = extensions_.find(number); | 455 map<int, Extension>::iterator iter = extensions_.find(number); |
457 GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empt
y)."; | 456 GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empt
y)."; |
458 GOOGLE_DCHECK_TYPE(iter->second, REPEATED, ENUM); | 457 GOOGLE_DCHECK_TYPE(iter->second, REPEATED, ENUM); |
459 iter->second.repeated_enum_value->Set(index, value); | 458 iter->second.repeated_enum_value->Set(index, value); |
460 } | 459 } |
461 | 460 |
462 void ExtensionSet::AddEnum(int number, FieldType type, | 461 void ExtensionSet::AddEnum(int number, FieldType type, |
463 bool packed, int value, | 462 bool packed, int value, |
464 const FieldDescriptor* descriptor) { | 463 const FieldDescriptor* descriptor) { |
465 Extension* extension; | 464 Extension* extension; |
466 if (MaybeNewExtension(number, descriptor, &extension)) { | 465 if (MaybeNewExtension(number, descriptor, &extension)) { |
467 extension->type = type; | 466 extension->type = type; |
468 GOOGLE_DCHECK_EQ(cpp_type(extension->type), WireFormatLite::CPPTYPE_ENUM); | 467 GOOGLE_DCHECK_EQ(cpp_type(extension->type), WireFormatLite::CPPTYPE_ENUM); |
469 extension->is_repeated = true; | 468 extension->is_repeated = true; |
470 extension->is_packed = packed; | 469 extension->is_packed = packed; |
471 extension->repeated_enum_value = | 470 extension->repeated_enum_value = |
472 Arena::CreateMessage<RepeatedField<int> >(arena_); | 471 Arena::CreateMessage<RepeatedField<int> >(arena_); |
473 } else { | 472 } else { |
474 GOOGLE_DCHECK_TYPE(*extension, REPEATED, ENUM); | 473 GOOGLE_DCHECK_TYPE(*extension, REPEATED, ENUM); |
475 GOOGLE_DCHECK_EQ(extension->is_packed, packed); | 474 GOOGLE_DCHECK_EQ(extension->is_packed, packed); |
476 } | 475 } |
477 extension->repeated_enum_value->Add(value); | 476 extension->repeated_enum_value->Add(value); |
478 } | 477 } |
479 | 478 |
480 // ------------------------------------------------------------------- | 479 // ------------------------------------------------------------------- |
481 // Strings | 480 // Strings |
482 | 481 |
483 const string& ExtensionSet::GetString(int number, | 482 const string& ExtensionSet::GetString(int number, |
484 const string& default_value) const { | 483 const string& default_value) const { |
485 ExtensionMap::const_iterator iter = extensions_.find(number); | 484 map<int, Extension>::const_iterator iter = extensions_.find(number); |
486 if (iter == extensions_.end() || iter->second.is_cleared) { | 485 if (iter == extensions_.end() || iter->second.is_cleared) { |
487 // Not present. Return the default value. | 486 // Not present. Return the default value. |
488 return default_value; | 487 return default_value; |
489 } else { | 488 } else { |
490 GOOGLE_DCHECK_TYPE(iter->second, OPTIONAL, STRING); | 489 GOOGLE_DCHECK_TYPE(iter->second, OPTIONAL, STRING); |
491 return *iter->second.string_value; | 490 return *iter->second.string_value; |
492 } | 491 } |
493 } | 492 } |
494 | 493 |
495 string* ExtensionSet::MutableString(int number, FieldType type, | 494 string* ExtensionSet::MutableString(int number, FieldType type, |
496 const FieldDescriptor* descriptor) { | 495 const FieldDescriptor* descriptor) { |
497 Extension* extension; | 496 Extension* extension; |
498 if (MaybeNewExtension(number, descriptor, &extension)) { | 497 if (MaybeNewExtension(number, descriptor, &extension)) { |
499 extension->type = type; | 498 extension->type = type; |
500 GOOGLE_DCHECK_EQ(cpp_type(extension->type), WireFormatLite::CPPTYPE_STRING); | 499 GOOGLE_DCHECK_EQ(cpp_type(extension->type), WireFormatLite::CPPTYPE_STRING); |
501 extension->is_repeated = false; | 500 extension->is_repeated = false; |
502 extension->string_value = Arena::Create<string>(arena_); | 501 extension->string_value = Arena::Create<string>(arena_); |
503 } else { | 502 } else { |
504 GOOGLE_DCHECK_TYPE(*extension, OPTIONAL, STRING); | 503 GOOGLE_DCHECK_TYPE(*extension, OPTIONAL, STRING); |
505 } | 504 } |
506 extension->is_cleared = false; | 505 extension->is_cleared = false; |
507 return extension->string_value; | 506 return extension->string_value; |
508 } | 507 } |
509 | 508 |
510 const string& ExtensionSet::GetRepeatedString(int number, int index) const { | 509 const string& ExtensionSet::GetRepeatedString(int number, int index) const { |
511 ExtensionMap::const_iterator iter = extensions_.find(number); | 510 map<int, Extension>::const_iterator iter = extensions_.find(number); |
512 GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empt
y)."; | 511 GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empt
y)."; |
513 GOOGLE_DCHECK_TYPE(iter->second, REPEATED, STRING); | 512 GOOGLE_DCHECK_TYPE(iter->second, REPEATED, STRING); |
514 return iter->second.repeated_string_value->Get(index); | 513 return iter->second.repeated_string_value->Get(index); |
515 } | 514 } |
516 | 515 |
517 string* ExtensionSet::MutableRepeatedString(int number, int index) { | 516 string* ExtensionSet::MutableRepeatedString(int number, int index) { |
518 ExtensionMap::iterator iter = extensions_.find(number); | 517 map<int, Extension>::iterator iter = extensions_.find(number); |
519 GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empt
y)."; | 518 GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empt
y)."; |
520 GOOGLE_DCHECK_TYPE(iter->second, REPEATED, STRING); | 519 GOOGLE_DCHECK_TYPE(iter->second, REPEATED, STRING); |
521 return iter->second.repeated_string_value->Mutable(index); | 520 return iter->second.repeated_string_value->Mutable(index); |
522 } | 521 } |
523 | 522 |
524 string* ExtensionSet::AddString(int number, FieldType type, | 523 string* ExtensionSet::AddString(int number, FieldType type, |
525 const FieldDescriptor* descriptor) { | 524 const FieldDescriptor* descriptor) { |
526 Extension* extension; | 525 Extension* extension; |
527 if (MaybeNewExtension(number, descriptor, &extension)) { | 526 if (MaybeNewExtension(number, descriptor, &extension)) { |
528 extension->type = type; | 527 extension->type = type; |
529 GOOGLE_DCHECK_EQ(cpp_type(extension->type), WireFormatLite::CPPTYPE_STRING); | 528 GOOGLE_DCHECK_EQ(cpp_type(extension->type), WireFormatLite::CPPTYPE_STRING); |
530 extension->is_repeated = true; | 529 extension->is_repeated = true; |
531 extension->is_packed = false; | 530 extension->is_packed = false; |
532 extension->repeated_string_value = | 531 extension->repeated_string_value = |
533 Arena::CreateMessage<RepeatedPtrField<string> >(arena_); | 532 Arena::CreateMessage<RepeatedPtrField<string> >(arena_); |
534 } else { | 533 } else { |
535 GOOGLE_DCHECK_TYPE(*extension, REPEATED, STRING); | 534 GOOGLE_DCHECK_TYPE(*extension, REPEATED, STRING); |
536 } | 535 } |
537 return extension->repeated_string_value->Add(); | 536 return extension->repeated_string_value->Add(); |
538 } | 537 } |
539 | 538 |
540 // ------------------------------------------------------------------- | 539 // ------------------------------------------------------------------- |
541 // Messages | 540 // Messages |
542 | 541 |
543 const MessageLite& ExtensionSet::GetMessage( | 542 const MessageLite& ExtensionSet::GetMessage( |
544 int number, const MessageLite& default_value) const { | 543 int number, const MessageLite& default_value) const { |
545 ExtensionMap::const_iterator iter = extensions_.find(number); | 544 map<int, Extension>::const_iterator iter = extensions_.find(number); |
546 if (iter == extensions_.end()) { | 545 if (iter == extensions_.end()) { |
547 // Not present. Return the default value. | 546 // Not present. Return the default value. |
548 return default_value; | 547 return default_value; |
549 } else { | 548 } else { |
550 GOOGLE_DCHECK_TYPE(iter->second, OPTIONAL, MESSAGE); | 549 GOOGLE_DCHECK_TYPE(iter->second, OPTIONAL, MESSAGE); |
551 if (iter->second.is_lazy) { | 550 if (iter->second.is_lazy) { |
552 return iter->second.lazymessage_value->GetMessage(default_value); | 551 return iter->second.lazymessage_value->GetMessage(default_value); |
553 } else { | 552 } else { |
554 return *iter->second.message_value; | 553 return *iter->second.message_value; |
555 } | 554 } |
(...skipping 102 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
658 } | 657 } |
659 extension->message_value = message; | 658 extension->message_value = message; |
660 } | 659 } |
661 } | 660 } |
662 extension->is_cleared = false; | 661 extension->is_cleared = false; |
663 } | 662 } |
664 | 663 |
665 | 664 |
666 MessageLite* ExtensionSet::ReleaseMessage(int number, | 665 MessageLite* ExtensionSet::ReleaseMessage(int number, |
667 const MessageLite& prototype) { | 666 const MessageLite& prototype) { |
668 ExtensionMap::iterator iter = extensions_.find(number); | 667 map<int, Extension>::iterator iter = extensions_.find(number); |
669 if (iter == extensions_.end()) { | 668 if (iter == extensions_.end()) { |
670 // Not present. Return NULL. | 669 // Not present. Return NULL. |
671 return NULL; | 670 return NULL; |
672 } else { | 671 } else { |
673 GOOGLE_DCHECK_TYPE(iter->second, OPTIONAL, MESSAGE); | 672 GOOGLE_DCHECK_TYPE(iter->second, OPTIONAL, MESSAGE); |
674 MessageLite* ret = NULL; | 673 MessageLite* ret = NULL; |
675 if (iter->second.is_lazy) { | 674 if (iter->second.is_lazy) { |
676 ret = iter->second.lazymessage_value->ReleaseMessage(prototype); | 675 ret = iter->second.lazymessage_value->ReleaseMessage(prototype); |
677 if (arena_ == NULL) { | 676 if (arena_ == NULL) { |
678 delete iter->second.lazymessage_value; | 677 delete iter->second.lazymessage_value; |
679 } | 678 } |
680 } else { | 679 } else { |
681 if (arena_ == NULL) { | 680 if (arena_ == NULL) { |
682 ret = iter->second.message_value; | 681 ret = iter->second.message_value; |
683 } else { | 682 } else { |
684 // ReleaseMessage() always returns a heap-allocated message, and we are | 683 // ReleaseMessage() always returns a heap-allocated message, and we are |
685 // on an arena, so we need to make a copy of this message to return. | 684 // on an arena, so we need to make a copy of this message to return. |
686 ret = (iter->second.message_value)->New(); | 685 ret = (iter->second.message_value)->New(); |
687 ret->CheckTypeAndMergeFrom(*iter->second.message_value); | 686 ret->CheckTypeAndMergeFrom(*iter->second.message_value); |
688 } | 687 } |
689 } | 688 } |
690 extensions_.erase(number); | 689 extensions_.erase(number); |
691 return ret; | 690 return ret; |
692 } | 691 } |
693 } | 692 } |
694 | 693 |
695 MessageLite* ExtensionSet::UnsafeArenaReleaseMessage( | 694 MessageLite* ExtensionSet::UnsafeArenaReleaseMessage( |
696 int number, const MessageLite& prototype) { | 695 int number, const MessageLite& prototype) { |
697 ExtensionMap::iterator iter = extensions_.find(number); | 696 map<int, Extension>::iterator iter = extensions_.find(number); |
698 if (iter == extensions_.end()) { | 697 if (iter == extensions_.end()) { |
699 // Not present. Return NULL. | 698 // Not present. Return NULL. |
700 return NULL; | 699 return NULL; |
701 } else { | 700 } else { |
702 GOOGLE_DCHECK_TYPE(iter->second, OPTIONAL, MESSAGE); | 701 GOOGLE_DCHECK_TYPE(iter->second, OPTIONAL, MESSAGE); |
703 MessageLite* ret = NULL; | 702 MessageLite* ret = NULL; |
704 if (iter->second.is_lazy) { | 703 if (iter->second.is_lazy) { |
705 ret = | 704 ret = |
706 iter->second.lazymessage_value->UnsafeArenaReleaseMessage(prototype); | 705 iter->second.lazymessage_value->UnsafeArenaReleaseMessage(prototype); |
707 if (arena_ == NULL) { | 706 if (arena_ == NULL) { |
708 delete iter->second.lazymessage_value; | 707 delete iter->second.lazymessage_value; |
709 } | 708 } |
710 } else { | 709 } else { |
711 ret = iter->second.message_value; | 710 ret = iter->second.message_value; |
712 } | 711 } |
713 extensions_.erase(number); | 712 extensions_.erase(number); |
714 return ret; | 713 return ret; |
715 } | 714 } |
716 } | 715 } |
717 | 716 |
718 // Defined in extension_set_heavy.cc. | 717 // Defined in extension_set_heavy.cc. |
719 // MessageLite* ExtensionSet::ReleaseMessage(const FieldDescriptor* descriptor, | 718 // MessageLite* ExtensionSet::ReleaseMessage(const FieldDescriptor* descriptor, |
720 // MessageFactory* factory); | 719 // MessageFactory* factory); |
721 | 720 |
722 const MessageLite& ExtensionSet::GetRepeatedMessage( | 721 const MessageLite& ExtensionSet::GetRepeatedMessage( |
723 int number, int index) const { | 722 int number, int index) const { |
724 ExtensionMap::const_iterator iter = extensions_.find(number); | 723 map<int, Extension>::const_iterator iter = extensions_.find(number); |
725 GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empt
y)."; | 724 GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empt
y)."; |
726 GOOGLE_DCHECK_TYPE(iter->second, REPEATED, MESSAGE); | 725 GOOGLE_DCHECK_TYPE(iter->second, REPEATED, MESSAGE); |
727 return iter->second.repeated_message_value->Get(index); | 726 return iter->second.repeated_message_value->Get(index); |
728 } | 727 } |
729 | 728 |
730 MessageLite* ExtensionSet::MutableRepeatedMessage(int number, int index) { | 729 MessageLite* ExtensionSet::MutableRepeatedMessage(int number, int index) { |
731 ExtensionMap::iterator iter = extensions_.find(number); | 730 map<int, Extension>::iterator iter = extensions_.find(number); |
732 GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empt
y)."; | 731 GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empt
y)."; |
733 GOOGLE_DCHECK_TYPE(iter->second, REPEATED, MESSAGE); | 732 GOOGLE_DCHECK_TYPE(iter->second, REPEATED, MESSAGE); |
734 return iter->second.repeated_message_value->Mutable(index); | 733 return iter->second.repeated_message_value->Mutable(index); |
735 } | 734 } |
736 | 735 |
737 MessageLite* ExtensionSet::AddMessage(int number, FieldType type, | 736 MessageLite* ExtensionSet::AddMessage(int number, FieldType type, |
738 const MessageLite& prototype, | 737 const MessageLite& prototype, |
739 const FieldDescriptor* descriptor) { | 738 const FieldDescriptor* descriptor) { |
740 Extension* extension; | 739 Extension* extension; |
741 if (MaybeNewExtension(number, descriptor, &extension)) { | 740 if (MaybeNewExtension(number, descriptor, &extension)) { |
(...skipping 18 matching lines...) Expand all Loading... |
760 } | 759 } |
761 | 760 |
762 // Defined in extension_set_heavy.cc. | 761 // Defined in extension_set_heavy.cc. |
763 // MessageLite* ExtensionSet::AddMessage(int number, FieldType type, | 762 // MessageLite* ExtensionSet::AddMessage(int number, FieldType type, |
764 // const Descriptor* message_type, | 763 // const Descriptor* message_type, |
765 // MessageFactory* factory) | 764 // MessageFactory* factory) |
766 | 765 |
767 #undef GOOGLE_DCHECK_TYPE | 766 #undef GOOGLE_DCHECK_TYPE |
768 | 767 |
769 void ExtensionSet::RemoveLast(int number) { | 768 void ExtensionSet::RemoveLast(int number) { |
770 ExtensionMap::iterator iter = extensions_.find(number); | 769 map<int, Extension>::iterator iter = extensions_.find(number); |
771 GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empt
y)."; | 770 GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empt
y)."; |
772 | 771 |
773 Extension* extension = &iter->second; | 772 Extension* extension = &iter->second; |
774 GOOGLE_DCHECK(extension->is_repeated); | 773 GOOGLE_DCHECK(extension->is_repeated); |
775 | 774 |
776 switch(cpp_type(extension->type)) { | 775 switch(cpp_type(extension->type)) { |
777 case WireFormatLite::CPPTYPE_INT32: | 776 case WireFormatLite::CPPTYPE_INT32: |
778 extension->repeated_int32_value->RemoveLast(); | 777 extension->repeated_int32_value->RemoveLast(); |
779 break; | 778 break; |
780 case WireFormatLite::CPPTYPE_INT64: | 779 case WireFormatLite::CPPTYPE_INT64: |
(...skipping 20 matching lines...) Expand all Loading... |
801 case WireFormatLite::CPPTYPE_STRING: | 800 case WireFormatLite::CPPTYPE_STRING: |
802 extension->repeated_string_value->RemoveLast(); | 801 extension->repeated_string_value->RemoveLast(); |
803 break; | 802 break; |
804 case WireFormatLite::CPPTYPE_MESSAGE: | 803 case WireFormatLite::CPPTYPE_MESSAGE: |
805 extension->repeated_message_value->RemoveLast(); | 804 extension->repeated_message_value->RemoveLast(); |
806 break; | 805 break; |
807 } | 806 } |
808 } | 807 } |
809 | 808 |
810 MessageLite* ExtensionSet::ReleaseLast(int number) { | 809 MessageLite* ExtensionSet::ReleaseLast(int number) { |
811 ExtensionMap::iterator iter = extensions_.find(number); | 810 map<int, Extension>::iterator iter = extensions_.find(number); |
812 GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empt
y)."; | 811 GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empt
y)."; |
813 | 812 |
814 Extension* extension = &iter->second; | 813 Extension* extension = &iter->second; |
815 GOOGLE_DCHECK(extension->is_repeated); | 814 GOOGLE_DCHECK(extension->is_repeated); |
816 GOOGLE_DCHECK(cpp_type(extension->type) == WireFormatLite::CPPTYPE_MESSAGE); | 815 GOOGLE_DCHECK(cpp_type(extension->type) == WireFormatLite::CPPTYPE_MESSAGE); |
817 return extension->repeated_message_value->ReleaseLast(); | 816 return extension->repeated_message_value->ReleaseLast(); |
818 } | 817 } |
819 | 818 |
820 void ExtensionSet::SwapElements(int number, int index1, int index2) { | 819 void ExtensionSet::SwapElements(int number, int index1, int index2) { |
821 ExtensionMap::iterator iter = extensions_.find(number); | 820 map<int, Extension>::iterator iter = extensions_.find(number); |
822 GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empt
y)."; | 821 GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empt
y)."; |
823 | 822 |
824 Extension* extension = &iter->second; | 823 Extension* extension = &iter->second; |
825 GOOGLE_DCHECK(extension->is_repeated); | 824 GOOGLE_DCHECK(extension->is_repeated); |
826 | 825 |
827 switch(cpp_type(extension->type)) { | 826 switch(cpp_type(extension->type)) { |
828 case WireFormatLite::CPPTYPE_INT32: | 827 case WireFormatLite::CPPTYPE_INT32: |
829 extension->repeated_int32_value->SwapElements(index1, index2); | 828 extension->repeated_int32_value->SwapElements(index1, index2); |
830 break; | 829 break; |
831 case WireFormatLite::CPPTYPE_INT64: | 830 case WireFormatLite::CPPTYPE_INT64: |
(...skipping 22 matching lines...) Expand all Loading... |
854 break; | 853 break; |
855 case WireFormatLite::CPPTYPE_MESSAGE: | 854 case WireFormatLite::CPPTYPE_MESSAGE: |
856 extension->repeated_message_value->SwapElements(index1, index2); | 855 extension->repeated_message_value->SwapElements(index1, index2); |
857 break; | 856 break; |
858 } | 857 } |
859 } | 858 } |
860 | 859 |
861 // =================================================================== | 860 // =================================================================== |
862 | 861 |
863 void ExtensionSet::Clear() { | 862 void ExtensionSet::Clear() { |
864 for (ExtensionMap::iterator iter = extensions_.begin(); | 863 for (map<int, Extension>::iterator iter = extensions_.begin(); |
865 iter != extensions_.end(); ++iter) { | 864 iter != extensions_.end(); ++iter) { |
866 iter->second.Clear(); | 865 iter->second.Clear(); |
867 } | 866 } |
868 } | 867 } |
869 | 868 |
870 void ExtensionSet::MergeFrom(const ExtensionSet& other) { | 869 void ExtensionSet::MergeFrom(const ExtensionSet& other) { |
871 for (ExtensionMap::const_iterator iter = other.extensions_.begin(); | 870 for (map<int, Extension>::const_iterator iter = other.extensions_.begin(); |
872 iter != other.extensions_.end(); ++iter) { | 871 iter != other.extensions_.end(); ++iter) { |
873 const Extension& other_extension = iter->second; | 872 const Extension& other_extension = iter->second; |
874 InternalExtensionMergeFrom(iter->first, other_extension); | 873 InternalExtensionMergeFrom(iter->first, other_extension); |
875 } | 874 } |
876 } | 875 } |
877 | 876 |
878 void ExtensionSet::InternalExtensionMergeFrom( | 877 void ExtensionSet::InternalExtensionMergeFrom( |
879 int number, const Extension& other_extension) { | 878 int number, const Extension& other_extension) { |
880 if (other_extension.is_repeated) { | 879 if (other_extension.is_repeated) { |
881 Extension* extension; | 880 Extension* extension; |
(...skipping 143 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1025 x->Clear(); | 1024 x->Clear(); |
1026 x->MergeFrom(*this); | 1025 x->MergeFrom(*this); |
1027 Clear(); | 1026 Clear(); |
1028 MergeFrom(extension_set); | 1027 MergeFrom(extension_set); |
1029 } | 1028 } |
1030 } | 1029 } |
1031 | 1030 |
1032 void ExtensionSet::SwapExtension(ExtensionSet* other, | 1031 void ExtensionSet::SwapExtension(ExtensionSet* other, |
1033 int number) { | 1032 int number) { |
1034 if (this == other) return; | 1033 if (this == other) return; |
1035 ExtensionMap::iterator this_iter = extensions_.find(number); | 1034 map<int, Extension>::iterator this_iter = extensions_.find(number); |
1036 ExtensionMap::iterator other_iter = other->extensions_.find(number); | 1035 map<int, Extension>::iterator other_iter = other->extensions_.find(number); |
1037 | 1036 |
1038 if (this_iter == extensions_.end() && | 1037 if (this_iter == extensions_.end() && |
1039 other_iter == other->extensions_.end()) { | 1038 other_iter == other->extensions_.end()) { |
1040 return; | 1039 return; |
1041 } | 1040 } |
1042 | 1041 |
1043 if (this_iter != extensions_.end() && | 1042 if (this_iter != extensions_.end() && |
1044 other_iter != other->extensions_.end()) { | 1043 other_iter != other->extensions_.end()) { |
1045 if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) { | 1044 if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) { |
1046 using std::swap; | 1045 using std::swap; |
1047 swap(this_iter->second, other_iter->second); | 1046 swap(this_iter->second, other_iter->second); |
1048 } else { | 1047 } else { |
1049 // TODO(cfallin, rohananil): We could further optimize these cases, | 1048 // TODO(cfallin, rohananil): We could further optimize these cases, |
1050 // especially avoid creation of ExtensionSet, and move MergeFrom logic | 1049 // especially avoid creation of ExtensionSet, and move MergeFrom logic |
1051 // into Extensions itself (which takes arena as an argument). | 1050 // into Extensions itself (which takes arena as an argument). |
1052 // We do it this way to reuse the copy-across-arenas logic already | 1051 // We do it this way to reuse the copy-across-arenas logic already |
1053 // implemented in ExtensionSet's MergeFrom. | 1052 // implemented in ExtensionSet's MergeFrom. |
1054 ExtensionSet temp; | 1053 ExtensionSet temp; |
1055 temp.InternalExtensionMergeFrom(number, other_iter->second); | 1054 temp.InternalExtensionMergeFrom(number, other_iter->second); |
1056 ExtensionMap::iterator temp_iter = temp.extensions_.find(number); | 1055 map<int, Extension>::iterator temp_iter = temp.extensions_.find(number); |
1057 other_iter->second.Clear(); | 1056 other_iter->second.Clear(); |
1058 other->InternalExtensionMergeFrom(number, this_iter->second); | 1057 other->InternalExtensionMergeFrom(number, this_iter->second); |
1059 this_iter->second.Clear(); | 1058 this_iter->second.Clear(); |
1060 InternalExtensionMergeFrom(number, temp_iter->second); | 1059 InternalExtensionMergeFrom(number, temp_iter->second); |
1061 } | 1060 } |
1062 return; | 1061 return; |
1063 } | 1062 } |
1064 | 1063 |
1065 if (this_iter == extensions_.end()) { | 1064 if (this_iter == extensions_.end()) { |
1066 if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) { | 1065 if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) { |
(...skipping 12 matching lines...) Expand all Loading... |
1079 other->InternalExtensionMergeFrom(number, this_iter->second); | 1078 other->InternalExtensionMergeFrom(number, this_iter->second); |
1080 } | 1079 } |
1081 extensions_.erase(number); | 1080 extensions_.erase(number); |
1082 return; | 1081 return; |
1083 } | 1082 } |
1084 } | 1083 } |
1085 | 1084 |
1086 bool ExtensionSet::IsInitialized() const { | 1085 bool ExtensionSet::IsInitialized() const { |
1087 // Extensions are never required. However, we need to check that all | 1086 // Extensions are never required. However, we need to check that all |
1088 // embedded messages are initialized. | 1087 // embedded messages are initialized. |
1089 for (ExtensionMap::const_iterator iter = extensions_.begin(); | 1088 for (map<int, Extension>::const_iterator iter = extensions_.begin(); |
1090 iter != extensions_.end(); ++iter) { | 1089 iter != extensions_.end(); ++iter) { |
1091 const Extension& extension = iter->second; | 1090 const Extension& extension = iter->second; |
1092 if (cpp_type(extension.type) == WireFormatLite::CPPTYPE_MESSAGE) { | 1091 if (cpp_type(extension.type) == WireFormatLite::CPPTYPE_MESSAGE) { |
1093 if (extension.is_repeated) { | 1092 if (extension.is_repeated) { |
1094 for (int i = 0; i < extension.repeated_message_value->size(); i++) { | 1093 for (int i = 0; i < extension.repeated_message_value->size(); i++) { |
1095 if (!extension.repeated_message_value->Get(i).IsInitialized()) { | 1094 if (!extension.repeated_message_value->Get(i).IsInitialized()) { |
1096 return false; | 1095 return false; |
1097 } | 1096 } |
1098 } | 1097 } |
1099 } else { | 1098 } else { |
(...skipping 239 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1339 // UnknownFieldSet* unknown_fields) | 1338 // UnknownFieldSet* unknown_fields) |
1340 | 1339 |
1341 // Defined in extension_set_heavy.cc. | 1340 // Defined in extension_set_heavy.cc. |
1342 // bool ExtensionSet::ParseMessageSet(io::CodedInputStream* input, | 1341 // bool ExtensionSet::ParseMessageSet(io::CodedInputStream* input, |
1343 // const MessageLite* containing_type, | 1342 // const MessageLite* containing_type, |
1344 // UnknownFieldSet* unknown_fields); | 1343 // UnknownFieldSet* unknown_fields); |
1345 | 1344 |
1346 void ExtensionSet::SerializeWithCachedSizes( | 1345 void ExtensionSet::SerializeWithCachedSizes( |
1347 int start_field_number, int end_field_number, | 1346 int start_field_number, int end_field_number, |
1348 io::CodedOutputStream* output) const { | 1347 io::CodedOutputStream* output) const { |
1349 ExtensionMap::const_iterator iter; | 1348 map<int, Extension>::const_iterator iter; |
1350 for (iter = extensions_.lower_bound(start_field_number); | 1349 for (iter = extensions_.lower_bound(start_field_number); |
1351 iter != extensions_.end() && iter->first < end_field_number; | 1350 iter != extensions_.end() && iter->first < end_field_number; |
1352 ++iter) { | 1351 ++iter) { |
1353 iter->second.SerializeFieldWithCachedSizes(iter->first, output); | 1352 iter->second.SerializeFieldWithCachedSizes(iter->first, output); |
1354 } | 1353 } |
1355 } | 1354 } |
1356 | 1355 |
1357 size_t ExtensionSet::ByteSize() const { | 1356 int ExtensionSet::ByteSize() const { |
1358 size_t total_size = 0; | 1357 int total_size = 0; |
1359 | 1358 |
1360 for (ExtensionMap::const_iterator iter = extensions_.begin(); | 1359 for (map<int, Extension>::const_iterator iter = extensions_.begin(); |
1361 iter != extensions_.end(); ++iter) { | 1360 iter != extensions_.end(); ++iter) { |
1362 total_size += iter->second.ByteSize(iter->first); | 1361 total_size += iter->second.ByteSize(iter->first); |
1363 } | 1362 } |
1364 | 1363 |
1365 return total_size; | 1364 return total_size; |
1366 } | 1365 } |
1367 | 1366 |
1368 // Defined in extension_set_heavy.cc. | 1367 // Defined in extension_set_heavy.cc. |
1369 // int ExtensionSet::SpaceUsedExcludingSelf() const | 1368 // int ExtensionSet::SpaceUsedExcludingSelf() const |
1370 | 1369 |
1371 bool ExtensionSet::MaybeNewExtension(int number, | 1370 bool ExtensionSet::MaybeNewExtension(int number, |
1372 const FieldDescriptor* descriptor, | 1371 const FieldDescriptor* descriptor, |
1373 Extension** result) { | 1372 Extension** result) { |
1374 std::pair<ExtensionMap::iterator, bool> insert_result = | 1373 pair<map<int, Extension>::iterator, bool> insert_result = |
1375 extensions_.insert(std::make_pair(number, Extension())); | 1374 extensions_.insert(std::make_pair(number, Extension())); |
1376 *result = &insert_result.first->second; | 1375 *result = &insert_result.first->second; |
1377 (*result)->descriptor = descriptor; | 1376 (*result)->descriptor = descriptor; |
1378 return insert_result.second; | 1377 return insert_result.second; |
1379 } | 1378 } |
1380 | 1379 |
1381 // =================================================================== | 1380 // =================================================================== |
1382 // Methods of ExtensionSet::Extension | 1381 // Methods of ExtensionSet::Extension |
1383 | 1382 |
1384 void ExtensionSet::Extension::Clear() { | 1383 void ExtensionSet::Extension::Clear() { |
(...skipping 144 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1529 if (is_lazy) { | 1528 if (is_lazy) { |
1530 lazymessage_value->WriteMessage(number, output); | 1529 lazymessage_value->WriteMessage(number, output); |
1531 } else { | 1530 } else { |
1532 WireFormatLite::WriteMessage(number, *message_value, output); | 1531 WireFormatLite::WriteMessage(number, *message_value, output); |
1533 } | 1532 } |
1534 break; | 1533 break; |
1535 } | 1534 } |
1536 } | 1535 } |
1537 } | 1536 } |
1538 | 1537 |
1539 size_t ExtensionSet::Extension::ByteSize(int number) const { | 1538 int ExtensionSet::Extension::ByteSize(int number) const { |
1540 size_t result = 0; | 1539 int result = 0; |
1541 | 1540 |
1542 if (is_repeated) { | 1541 if (is_repeated) { |
1543 if (is_packed) { | 1542 if (is_packed) { |
1544 switch (real_type(type)) { | 1543 switch (real_type(type)) { |
1545 #define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \ | 1544 #define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \ |
1546 case WireFormatLite::TYPE_##UPPERCASE: \ | 1545 case WireFormatLite::TYPE_##UPPERCASE: \ |
1547 for (int i = 0; i < repeated_##LOWERCASE##_value->size(); i++) { \ | 1546 for (int i = 0; i < repeated_##LOWERCASE##_value->size(); i++) { \ |
1548 result += WireFormatLite::CAMELCASE##Size( \ | 1547 result += WireFormatLite::CAMELCASE##Size( \ |
1549 repeated_##LOWERCASE##_value->Get(i)); \ | 1548 repeated_##LOWERCASE##_value->Get(i)); \ |
1550 } \ | 1549 } \ |
1551 break | 1550 break |
1552 | 1551 |
1553 HANDLE_TYPE( INT32, Int32, int32); | 1552 HANDLE_TYPE( INT32, Int32, int32); |
1554 HANDLE_TYPE( INT64, Int64, int64); | 1553 HANDLE_TYPE( INT64, Int64, int64); |
1555 HANDLE_TYPE( UINT32, UInt32, uint32); | 1554 HANDLE_TYPE( UINT32, UInt32, uint32); |
1556 HANDLE_TYPE( UINT64, UInt64, uint64); | 1555 HANDLE_TYPE( UINT64, UInt64, uint64); |
1557 HANDLE_TYPE( SINT32, SInt32, int32); | 1556 HANDLE_TYPE( SINT32, SInt32, int32); |
1558 HANDLE_TYPE( SINT64, SInt64, int64); | 1557 HANDLE_TYPE( SINT64, SInt64, int64); |
1559 HANDLE_TYPE( ENUM, Enum, enum); | 1558 HANDLE_TYPE( ENUM, Enum, enum); |
1560 #undef HANDLE_TYPE | 1559 #undef HANDLE_TYPE |
1561 | 1560 |
1562 // Stuff with fixed size. | 1561 // Stuff with fixed size. |
1563 #define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \ | 1562 #define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \ |
1564 case WireFormatLite::TYPE_##UPPERCASE: \ | 1563 case WireFormatLite::TYPE_##UPPERCASE: \ |
1565 result += WireFormatLite::k##CAMELCASE##Size * \ | 1564 result += WireFormatLite::k##CAMELCASE##Size * \ |
1566 FromIntSize(repeated_##LOWERCASE##_value->size()); \ | 1565 repeated_##LOWERCASE##_value->size(); \ |
1567 break | 1566 break |
1568 HANDLE_TYPE( FIXED32, Fixed32, uint32); | 1567 HANDLE_TYPE( FIXED32, Fixed32, uint32); |
1569 HANDLE_TYPE( FIXED64, Fixed64, uint64); | 1568 HANDLE_TYPE( FIXED64, Fixed64, uint64); |
1570 HANDLE_TYPE(SFIXED32, SFixed32, int32); | 1569 HANDLE_TYPE(SFIXED32, SFixed32, int32); |
1571 HANDLE_TYPE(SFIXED64, SFixed64, int64); | 1570 HANDLE_TYPE(SFIXED64, SFixed64, int64); |
1572 HANDLE_TYPE( FLOAT, Float, float); | 1571 HANDLE_TYPE( FLOAT, Float, float); |
1573 HANDLE_TYPE( DOUBLE, Double, double); | 1572 HANDLE_TYPE( DOUBLE, Double, double); |
1574 HANDLE_TYPE( BOOL, Bool, bool); | 1573 HANDLE_TYPE( BOOL, Bool, bool); |
1575 #undef HANDLE_TYPE | 1574 #undef HANDLE_TYPE |
1576 | 1575 |
1577 case WireFormatLite::TYPE_STRING: | 1576 case WireFormatLite::TYPE_STRING: |
1578 case WireFormatLite::TYPE_BYTES: | 1577 case WireFormatLite::TYPE_BYTES: |
1579 case WireFormatLite::TYPE_GROUP: | 1578 case WireFormatLite::TYPE_GROUP: |
1580 case WireFormatLite::TYPE_MESSAGE: | 1579 case WireFormatLite::TYPE_MESSAGE: |
1581 GOOGLE_LOG(FATAL) << "Non-primitive types can't be packed."; | 1580 GOOGLE_LOG(FATAL) << "Non-primitive types can't be packed."; |
1582 break; | 1581 break; |
1583 } | 1582 } |
1584 | 1583 |
1585 cached_size = ToCachedSize(result); | 1584 cached_size = result; |
1586 if (result > 0) { | 1585 if (result > 0) { |
1587 result += io::CodedOutputStream::VarintSize32(result); | 1586 result += io::CodedOutputStream::VarintSize32(result); |
1588 result += io::CodedOutputStream::VarintSize32( | 1587 result += io::CodedOutputStream::VarintSize32( |
1589 WireFormatLite::MakeTag(number, | 1588 WireFormatLite::MakeTag(number, |
1590 WireFormatLite::WIRETYPE_LENGTH_DELIMITED)); | 1589 WireFormatLite::WIRETYPE_LENGTH_DELIMITED)); |
1591 } | 1590 } |
1592 } else { | 1591 } else { |
1593 size_t tag_size = WireFormatLite::TagSize(number, real_type(type)); | 1592 int tag_size = WireFormatLite::TagSize(number, real_type(type)); |
1594 | 1593 |
1595 switch (real_type(type)) { | 1594 switch (real_type(type)) { |
1596 #define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \ | 1595 #define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \ |
1597 case WireFormatLite::TYPE_##UPPERCASE: \ | 1596 case WireFormatLite::TYPE_##UPPERCASE: \ |
1598 result += tag_size * \ | 1597 result += tag_size * repeated_##LOWERCASE##_value->size(); \ |
1599 FromIntSize(repeated_##LOWERCASE##_value->size()); \ | |
1600 for (int i = 0; i < repeated_##LOWERCASE##_value->size(); i++) { \ | 1598 for (int i = 0; i < repeated_##LOWERCASE##_value->size(); i++) { \ |
1601 result += WireFormatLite::CAMELCASE##Size( \ | 1599 result += WireFormatLite::CAMELCASE##Size( \ |
1602 repeated_##LOWERCASE##_value->Get(i)); \ | 1600 repeated_##LOWERCASE##_value->Get(i)); \ |
1603 } \ | 1601 } \ |
1604 break | 1602 break |
1605 | 1603 |
1606 HANDLE_TYPE( INT32, Int32, int32); | 1604 HANDLE_TYPE( INT32, Int32, int32); |
1607 HANDLE_TYPE( INT64, Int64, int64); | 1605 HANDLE_TYPE( INT64, Int64, int64); |
1608 HANDLE_TYPE( UINT32, UInt32, uint32); | 1606 HANDLE_TYPE( UINT32, UInt32, uint32); |
1609 HANDLE_TYPE( UINT64, UInt64, uint64); | 1607 HANDLE_TYPE( UINT64, UInt64, uint64); |
1610 HANDLE_TYPE( SINT32, SInt32, int32); | 1608 HANDLE_TYPE( SINT32, SInt32, int32); |
1611 HANDLE_TYPE( SINT64, SInt64, int64); | 1609 HANDLE_TYPE( SINT64, SInt64, int64); |
1612 HANDLE_TYPE( STRING, String, string); | 1610 HANDLE_TYPE( STRING, String, string); |
1613 HANDLE_TYPE( BYTES, Bytes, string); | 1611 HANDLE_TYPE( BYTES, Bytes, string); |
1614 HANDLE_TYPE( ENUM, Enum, enum); | 1612 HANDLE_TYPE( ENUM, Enum, enum); |
1615 HANDLE_TYPE( GROUP, Group, message); | 1613 HANDLE_TYPE( GROUP, Group, message); |
1616 HANDLE_TYPE( MESSAGE, Message, message); | 1614 HANDLE_TYPE( MESSAGE, Message, message); |
1617 #undef HANDLE_TYPE | 1615 #undef HANDLE_TYPE |
1618 | 1616 |
1619 // Stuff with fixed size. | 1617 // Stuff with fixed size. |
1620 #define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \ | 1618 #define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \ |
1621 case WireFormatLite::TYPE_##UPPERCASE: \ | 1619 case WireFormatLite::TYPE_##UPPERCASE: \ |
1622 result += (tag_size + WireFormatLite::k##CAMELCASE##Size) * \ | 1620 result += (tag_size + WireFormatLite::k##CAMELCASE##Size) * \ |
1623 FromIntSize(repeated_##LOWERCASE##_value->size()); \ | 1621 repeated_##LOWERCASE##_value->size(); \ |
1624 break | 1622 break |
1625 HANDLE_TYPE( FIXED32, Fixed32, uint32); | 1623 HANDLE_TYPE( FIXED32, Fixed32, uint32); |
1626 HANDLE_TYPE( FIXED64, Fixed64, uint64); | 1624 HANDLE_TYPE( FIXED64, Fixed64, uint64); |
1627 HANDLE_TYPE(SFIXED32, SFixed32, int32); | 1625 HANDLE_TYPE(SFIXED32, SFixed32, int32); |
1628 HANDLE_TYPE(SFIXED64, SFixed64, int64); | 1626 HANDLE_TYPE(SFIXED64, SFixed64, int64); |
1629 HANDLE_TYPE( FLOAT, Float, float); | 1627 HANDLE_TYPE( FLOAT, Float, float); |
1630 HANDLE_TYPE( DOUBLE, Double, double); | 1628 HANDLE_TYPE( DOUBLE, Double, double); |
1631 HANDLE_TYPE( BOOL, Bool, bool); | 1629 HANDLE_TYPE( BOOL, Bool, bool); |
1632 #undef HANDLE_TYPE | 1630 #undef HANDLE_TYPE |
1633 } | 1631 } |
(...skipping 12 matching lines...) Expand all Loading... |
1646 HANDLE_TYPE( UINT64, UInt64, uint64_value); | 1644 HANDLE_TYPE( UINT64, UInt64, uint64_value); |
1647 HANDLE_TYPE( SINT32, SInt32, int32_value); | 1645 HANDLE_TYPE( SINT32, SInt32, int32_value); |
1648 HANDLE_TYPE( SINT64, SInt64, int64_value); | 1646 HANDLE_TYPE( SINT64, SInt64, int64_value); |
1649 HANDLE_TYPE( STRING, String, *string_value); | 1647 HANDLE_TYPE( STRING, String, *string_value); |
1650 HANDLE_TYPE( BYTES, Bytes, *string_value); | 1648 HANDLE_TYPE( BYTES, Bytes, *string_value); |
1651 HANDLE_TYPE( ENUM, Enum, enum_value); | 1649 HANDLE_TYPE( ENUM, Enum, enum_value); |
1652 HANDLE_TYPE( GROUP, Group, *message_value); | 1650 HANDLE_TYPE( GROUP, Group, *message_value); |
1653 #undef HANDLE_TYPE | 1651 #undef HANDLE_TYPE |
1654 case WireFormatLite::TYPE_MESSAGE: { | 1652 case WireFormatLite::TYPE_MESSAGE: { |
1655 if (is_lazy) { | 1653 if (is_lazy) { |
1656 size_t size = lazymessage_value->ByteSize(); | 1654 int size = lazymessage_value->ByteSize(); |
1657 result += io::CodedOutputStream::VarintSize32(size) + size; | 1655 result += io::CodedOutputStream::VarintSize32(size) + size; |
1658 } else { | 1656 } else { |
1659 result += WireFormatLite::MessageSize(*message_value); | 1657 result += WireFormatLite::MessageSize(*message_value); |
1660 } | 1658 } |
1661 break; | 1659 break; |
1662 } | 1660 } |
1663 | 1661 |
1664 // Stuff with fixed size. | 1662 // Stuff with fixed size. |
1665 #define HANDLE_TYPE(UPPERCASE, CAMELCASE) \ | 1663 #define HANDLE_TYPE(UPPERCASE, CAMELCASE) \ |
1666 case WireFormatLite::TYPE_##UPPERCASE: \ | 1664 case WireFormatLite::TYPE_##UPPERCASE: \ |
(...skipping 141 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1808 const RepeatedField<bool>* | 1806 const RepeatedField<bool>* |
1809 RepeatedPrimitiveGenericTypeTraits::default_repeated_field_bool_ = NULL; | 1807 RepeatedPrimitiveGenericTypeTraits::default_repeated_field_bool_ = NULL; |
1810 const RepeatedStringTypeTraits::RepeatedFieldType* | 1808 const RepeatedStringTypeTraits::RepeatedFieldType* |
1811 RepeatedStringTypeTraits::default_repeated_field_ = NULL; | 1809 RepeatedStringTypeTraits::default_repeated_field_ = NULL; |
1812 const RepeatedMessageGenericTypeTraits::RepeatedFieldType* | 1810 const RepeatedMessageGenericTypeTraits::RepeatedFieldType* |
1813 RepeatedMessageGenericTypeTraits::default_repeated_field_ = NULL; | 1811 RepeatedMessageGenericTypeTraits::default_repeated_field_ = NULL; |
1814 | 1812 |
1815 } // namespace internal | 1813 } // namespace internal |
1816 } // namespace protobuf | 1814 } // namespace protobuf |
1817 } // namespace google | 1815 } // namespace google |
OLD | NEW |