added iOS source code
[wl-app.git] / iOS / Pods / Protobuf / objectivec / GPBMessage.m
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 #import "GPBMessage_PackagePrivate.h"
32
33 #import <objc/runtime.h>
34 #import <objc/message.h>
35 #import <stdatomic.h>
36
37 #import "GPBArray_PackagePrivate.h"
38 #import "GPBCodedInputStream_PackagePrivate.h"
39 #import "GPBCodedOutputStream_PackagePrivate.h"
40 #import "GPBDescriptor_PackagePrivate.h"
41 #import "GPBDictionary_PackagePrivate.h"
42 #import "GPBExtensionInternals.h"
43 #import "GPBExtensionRegistry.h"
44 #import "GPBRootObject_PackagePrivate.h"
45 #import "GPBUnknownFieldSet_PackagePrivate.h"
46 #import "GPBUtilities_PackagePrivate.h"
47
48 // Direct access is use for speed, to avoid even internally declaring things
49 // read/write, etc. The warning is enabled in the project to ensure code calling
50 // protos can turn on -Wdirect-ivar-access without issues.
51 #pragma clang diagnostic push
52 #pragma clang diagnostic ignored "-Wdirect-ivar-access"
53
54 NSString *const GPBMessageErrorDomain =
55     GPBNSStringifySymbol(GPBMessageErrorDomain);
56
57 NSString *const GPBErrorReasonKey = @"Reason";
58
59 static NSString *const kGPBDataCoderKey = @"GPBData";
60
61 //
62 // PLEASE REMEMBER:
63 //
64 // This is the base class for *all* messages generated, so any selector defined,
65 // *public* or *private* could end up colliding with a proto message field. So
66 // avoid using selectors that could match a property, use C functions to hide
67 // them, etc.
68 //
69
70 @interface GPBMessage () {
71  @package
72   GPBUnknownFieldSet *unknownFields_;
73   NSMutableDictionary *extensionMap_;
74   NSMutableDictionary *autocreatedExtensionMap_;
75
76   // If the object was autocreated, we remember the creator so that if we get
77   // mutated, we can inform the creator to make our field visible.
78   GPBMessage *autocreator_;
79   GPBFieldDescriptor *autocreatorField_;
80   GPBExtensionDescriptor *autocreatorExtension_;
81
82   // A lock to provide mutual exclusion from internal data that can be modified
83   // by *read* operations such as getters (autocreation of message fields and
84   // message extensions, not setting of values). Used to guarantee thread safety
85   // for concurrent reads on the message.
86   // NOTE: OSSpinLock may seem like a good fit here but Apple engineers have
87   // pointed out that they are vulnerable to live locking on iOS in cases of
88   // priority inversion:
89   //   http://mjtsai.com/blog/2015/12/16/osspinlock-is-unsafe/
90   //   https://lists.swift.org/pipermail/swift-dev/Week-of-Mon-20151214/000372.html
91   // Use of readOnlySemaphore_ must be prefaced by a call to
92   // GPBPrepareReadOnlySemaphore to ensure it has been created. This allows
93   // readOnlySemaphore_ to be only created when actually needed.
94   _Atomic(dispatch_semaphore_t) readOnlySemaphore_;
95 }
96 @end
97
98 static id CreateArrayForField(GPBFieldDescriptor *field,
99                               GPBMessage *autocreator)
100     __attribute__((ns_returns_retained));
101 static id GetOrCreateArrayIvarWithField(GPBMessage *self,
102                                         GPBFieldDescriptor *field,
103                                         GPBFileSyntax syntax);
104 static id GetArrayIvarWithField(GPBMessage *self, GPBFieldDescriptor *field);
105 static id CreateMapForField(GPBFieldDescriptor *field,
106                             GPBMessage *autocreator)
107     __attribute__((ns_returns_retained));
108 static id GetOrCreateMapIvarWithField(GPBMessage *self,
109                                       GPBFieldDescriptor *field,
110                                       GPBFileSyntax syntax);
111 static id GetMapIvarWithField(GPBMessage *self, GPBFieldDescriptor *field);
112 static NSMutableDictionary *CloneExtensionMap(NSDictionary *extensionMap,
113                                               NSZone *zone)
114     __attribute__((ns_returns_retained));
115
116 #ifdef DEBUG
117 static NSError *MessageError(NSInteger code, NSDictionary *userInfo) {
118   return [NSError errorWithDomain:GPBMessageErrorDomain
119                              code:code
120                          userInfo:userInfo];
121 }
122 #endif
123
124 static NSError *ErrorFromException(NSException *exception) {
125   NSError *error = nil;
126
127   if ([exception.name isEqual:GPBCodedInputStreamException]) {
128     NSDictionary *exceptionInfo = exception.userInfo;
129     error = exceptionInfo[GPBCodedInputStreamUnderlyingErrorKey];
130   }
131
132   if (!error) {
133     NSString *reason = exception.reason;
134     NSDictionary *userInfo = nil;
135     if ([reason length]) {
136       userInfo = @{ GPBErrorReasonKey : reason };
137     }
138
139     error = [NSError errorWithDomain:GPBMessageErrorDomain
140                                 code:GPBMessageErrorCodeOther
141                             userInfo:userInfo];
142   }
143   return error;
144 }
145
146 static void CheckExtension(GPBMessage *self,
147                            GPBExtensionDescriptor *extension) {
148   if (![self isKindOfClass:extension.containingMessageClass]) {
149     [NSException
150          raise:NSInvalidArgumentException
151         format:@"Extension %@ used on wrong class (%@ instead of %@)",
152                extension.singletonName,
153                [self class], extension.containingMessageClass];
154   }
155 }
156
157 static NSMutableDictionary *CloneExtensionMap(NSDictionary *extensionMap,
158                                               NSZone *zone) {
159   if (extensionMap.count == 0) {
160     return nil;
161   }
162   NSMutableDictionary *result = [[NSMutableDictionary allocWithZone:zone]
163       initWithCapacity:extensionMap.count];
164
165   for (GPBExtensionDescriptor *extension in extensionMap) {
166     id value = [extensionMap objectForKey:extension];
167     BOOL isMessageExtension = GPBExtensionIsMessage(extension);
168
169     if (extension.repeated) {
170       if (isMessageExtension) {
171         NSMutableArray *list =
172             [[NSMutableArray alloc] initWithCapacity:[value count]];
173         for (GPBMessage *listValue in value) {
174           GPBMessage *copiedValue = [listValue copyWithZone:zone];
175           [list addObject:copiedValue];
176           [copiedValue release];
177         }
178         [result setObject:list forKey:extension];
179         [list release];
180       } else {
181         NSMutableArray *copiedValue = [value mutableCopyWithZone:zone];
182         [result setObject:copiedValue forKey:extension];
183         [copiedValue release];
184       }
185     } else {
186       if (isMessageExtension) {
187         GPBMessage *copiedValue = [value copyWithZone:zone];
188         [result setObject:copiedValue forKey:extension];
189         [copiedValue release];
190       } else {
191         [result setObject:value forKey:extension];
192       }
193     }
194   }
195
196   return result;
197 }
198
199 static id CreateArrayForField(GPBFieldDescriptor *field,
200                               GPBMessage *autocreator) {
201   id result;
202   GPBDataType fieldDataType = GPBGetFieldDataType(field);
203   switch (fieldDataType) {
204     case GPBDataTypeBool:
205       result = [[GPBBoolArray alloc] init];
206       break;
207     case GPBDataTypeFixed32:
208     case GPBDataTypeUInt32:
209       result = [[GPBUInt32Array alloc] init];
210       break;
211     case GPBDataTypeInt32:
212     case GPBDataTypeSFixed32:
213     case GPBDataTypeSInt32:
214       result = [[GPBInt32Array alloc] init];
215       break;
216     case GPBDataTypeFixed64:
217     case GPBDataTypeUInt64:
218       result = [[GPBUInt64Array alloc] init];
219       break;
220     case GPBDataTypeInt64:
221     case GPBDataTypeSFixed64:
222     case GPBDataTypeSInt64:
223       result = [[GPBInt64Array alloc] init];
224       break;
225     case GPBDataTypeFloat:
226       result = [[GPBFloatArray alloc] init];
227       break;
228     case GPBDataTypeDouble:
229       result = [[GPBDoubleArray alloc] init];
230       break;
231
232     case GPBDataTypeEnum:
233       result = [[GPBEnumArray alloc]
234                   initWithValidationFunction:field.enumDescriptor.enumVerifier];
235       break;
236
237     case GPBDataTypeBytes:
238     case GPBDataTypeGroup:
239     case GPBDataTypeMessage:
240     case GPBDataTypeString:
241       if (autocreator) {
242         result = [[GPBAutocreatedArray alloc] init];
243       } else {
244         result = [[NSMutableArray alloc] init];
245       }
246       break;
247   }
248
249   if (autocreator) {
250     if (GPBDataTypeIsObject(fieldDataType)) {
251       GPBAutocreatedArray *autoArray = result;
252       autoArray->_autocreator =  autocreator;
253     } else {
254       GPBInt32Array *gpbArray = result;
255       gpbArray->_autocreator = autocreator;
256     }
257   }
258
259   return result;
260 }
261
262 static id CreateMapForField(GPBFieldDescriptor *field,
263                             GPBMessage *autocreator) {
264   id result;
265   GPBDataType keyDataType = field.mapKeyDataType;
266   GPBDataType valueDataType = GPBGetFieldDataType(field);
267   switch (keyDataType) {
268     case GPBDataTypeBool:
269       switch (valueDataType) {
270         case GPBDataTypeBool:
271           result = [[GPBBoolBoolDictionary alloc] init];
272           break;
273         case GPBDataTypeFixed32:
274         case GPBDataTypeUInt32:
275           result = [[GPBBoolUInt32Dictionary alloc] init];
276           break;
277         case GPBDataTypeInt32:
278         case GPBDataTypeSFixed32:
279         case GPBDataTypeSInt32:
280           result = [[GPBBoolInt32Dictionary alloc] init];
281           break;
282         case GPBDataTypeFixed64:
283         case GPBDataTypeUInt64:
284           result = [[GPBBoolUInt64Dictionary alloc] init];
285           break;
286         case GPBDataTypeInt64:
287         case GPBDataTypeSFixed64:
288         case GPBDataTypeSInt64:
289           result = [[GPBBoolInt64Dictionary alloc] init];
290           break;
291         case GPBDataTypeFloat:
292           result = [[GPBBoolFloatDictionary alloc] init];
293           break;
294         case GPBDataTypeDouble:
295           result = [[GPBBoolDoubleDictionary alloc] init];
296           break;
297         case GPBDataTypeEnum:
298           result = [[GPBBoolEnumDictionary alloc]
299               initWithValidationFunction:field.enumDescriptor.enumVerifier];
300           break;
301         case GPBDataTypeBytes:
302         case GPBDataTypeMessage:
303         case GPBDataTypeString:
304           result = [[GPBBoolObjectDictionary alloc] init];
305           break;
306         case GPBDataTypeGroup:
307           NSCAssert(NO, @"shouldn't happen");
308           return nil;
309       }
310       break;
311     case GPBDataTypeFixed32:
312     case GPBDataTypeUInt32:
313       switch (valueDataType) {
314         case GPBDataTypeBool:
315           result = [[GPBUInt32BoolDictionary alloc] init];
316           break;
317         case GPBDataTypeFixed32:
318         case GPBDataTypeUInt32:
319           result = [[GPBUInt32UInt32Dictionary alloc] init];
320           break;
321         case GPBDataTypeInt32:
322         case GPBDataTypeSFixed32:
323         case GPBDataTypeSInt32:
324           result = [[GPBUInt32Int32Dictionary alloc] init];
325           break;
326         case GPBDataTypeFixed64:
327         case GPBDataTypeUInt64:
328           result = [[GPBUInt32UInt64Dictionary alloc] init];
329           break;
330         case GPBDataTypeInt64:
331         case GPBDataTypeSFixed64:
332         case GPBDataTypeSInt64:
333           result = [[GPBUInt32Int64Dictionary alloc] init];
334           break;
335         case GPBDataTypeFloat:
336           result = [[GPBUInt32FloatDictionary alloc] init];
337           break;
338         case GPBDataTypeDouble:
339           result = [[GPBUInt32DoubleDictionary alloc] init];
340           break;
341         case GPBDataTypeEnum:
342           result = [[GPBUInt32EnumDictionary alloc]
343               initWithValidationFunction:field.enumDescriptor.enumVerifier];
344           break;
345         case GPBDataTypeBytes:
346         case GPBDataTypeMessage:
347         case GPBDataTypeString:
348           result = [[GPBUInt32ObjectDictionary alloc] init];
349           break;
350         case GPBDataTypeGroup:
351           NSCAssert(NO, @"shouldn't happen");
352           return nil;
353       }
354       break;
355     case GPBDataTypeInt32:
356     case GPBDataTypeSFixed32:
357     case GPBDataTypeSInt32:
358       switch (valueDataType) {
359         case GPBDataTypeBool:
360           result = [[GPBInt32BoolDictionary alloc] init];
361           break;
362         case GPBDataTypeFixed32:
363         case GPBDataTypeUInt32:
364           result = [[GPBInt32UInt32Dictionary alloc] init];
365           break;
366         case GPBDataTypeInt32:
367         case GPBDataTypeSFixed32:
368         case GPBDataTypeSInt32:
369           result = [[GPBInt32Int32Dictionary alloc] init];
370           break;
371         case GPBDataTypeFixed64:
372         case GPBDataTypeUInt64:
373           result = [[GPBInt32UInt64Dictionary alloc] init];
374           break;
375         case GPBDataTypeInt64:
376         case GPBDataTypeSFixed64:
377         case GPBDataTypeSInt64:
378           result = [[GPBInt32Int64Dictionary alloc] init];
379           break;
380         case GPBDataTypeFloat:
381           result = [[GPBInt32FloatDictionary alloc] init];
382           break;
383         case GPBDataTypeDouble:
384           result = [[GPBInt32DoubleDictionary alloc] init];
385           break;
386         case GPBDataTypeEnum:
387           result = [[GPBInt32EnumDictionary alloc]
388               initWithValidationFunction:field.enumDescriptor.enumVerifier];
389           break;
390         case GPBDataTypeBytes:
391         case GPBDataTypeMessage:
392         case GPBDataTypeString:
393           result = [[GPBInt32ObjectDictionary alloc] init];
394           break;
395         case GPBDataTypeGroup:
396           NSCAssert(NO, @"shouldn't happen");
397           return nil;
398       }
399       break;
400     case GPBDataTypeFixed64:
401     case GPBDataTypeUInt64:
402       switch (valueDataType) {
403         case GPBDataTypeBool:
404           result = [[GPBUInt64BoolDictionary alloc] init];
405           break;
406         case GPBDataTypeFixed32:
407         case GPBDataTypeUInt32:
408           result = [[GPBUInt64UInt32Dictionary alloc] init];
409           break;
410         case GPBDataTypeInt32:
411         case GPBDataTypeSFixed32:
412         case GPBDataTypeSInt32:
413           result = [[GPBUInt64Int32Dictionary alloc] init];
414           break;
415         case GPBDataTypeFixed64:
416         case GPBDataTypeUInt64:
417           result = [[GPBUInt64UInt64Dictionary alloc] init];
418           break;
419         case GPBDataTypeInt64:
420         case GPBDataTypeSFixed64:
421         case GPBDataTypeSInt64:
422           result = [[GPBUInt64Int64Dictionary alloc] init];
423           break;
424         case GPBDataTypeFloat:
425           result = [[GPBUInt64FloatDictionary alloc] init];
426           break;
427         case GPBDataTypeDouble:
428           result = [[GPBUInt64DoubleDictionary alloc] init];
429           break;
430         case GPBDataTypeEnum:
431           result = [[GPBUInt64EnumDictionary alloc]
432               initWithValidationFunction:field.enumDescriptor.enumVerifier];
433           break;
434         case GPBDataTypeBytes:
435         case GPBDataTypeMessage:
436         case GPBDataTypeString:
437           result = [[GPBUInt64ObjectDictionary alloc] init];
438           break;
439         case GPBDataTypeGroup:
440           NSCAssert(NO, @"shouldn't happen");
441           return nil;
442       }
443       break;
444     case GPBDataTypeInt64:
445     case GPBDataTypeSFixed64:
446     case GPBDataTypeSInt64:
447       switch (valueDataType) {
448         case GPBDataTypeBool:
449           result = [[GPBInt64BoolDictionary alloc] init];
450           break;
451         case GPBDataTypeFixed32:
452         case GPBDataTypeUInt32:
453           result = [[GPBInt64UInt32Dictionary alloc] init];
454           break;
455         case GPBDataTypeInt32:
456         case GPBDataTypeSFixed32:
457         case GPBDataTypeSInt32:
458           result = [[GPBInt64Int32Dictionary alloc] init];
459           break;
460         case GPBDataTypeFixed64:
461         case GPBDataTypeUInt64:
462           result = [[GPBInt64UInt64Dictionary alloc] init];
463           break;
464         case GPBDataTypeInt64:
465         case GPBDataTypeSFixed64:
466         case GPBDataTypeSInt64:
467           result = [[GPBInt64Int64Dictionary alloc] init];
468           break;
469         case GPBDataTypeFloat:
470           result = [[GPBInt64FloatDictionary alloc] init];
471           break;
472         case GPBDataTypeDouble:
473           result = [[GPBInt64DoubleDictionary alloc] init];
474           break;
475         case GPBDataTypeEnum:
476           result = [[GPBInt64EnumDictionary alloc]
477               initWithValidationFunction:field.enumDescriptor.enumVerifier];
478           break;
479         case GPBDataTypeBytes:
480         case GPBDataTypeMessage:
481         case GPBDataTypeString:
482           result = [[GPBInt64ObjectDictionary alloc] init];
483           break;
484         case GPBDataTypeGroup:
485           NSCAssert(NO, @"shouldn't happen");
486           return nil;
487       }
488       break;
489     case GPBDataTypeString:
490       switch (valueDataType) {
491         case GPBDataTypeBool:
492           result = [[GPBStringBoolDictionary alloc] init];
493           break;
494         case GPBDataTypeFixed32:
495         case GPBDataTypeUInt32:
496           result = [[GPBStringUInt32Dictionary alloc] init];
497           break;
498         case GPBDataTypeInt32:
499         case GPBDataTypeSFixed32:
500         case GPBDataTypeSInt32:
501           result = [[GPBStringInt32Dictionary alloc] init];
502           break;
503         case GPBDataTypeFixed64:
504         case GPBDataTypeUInt64:
505           result = [[GPBStringUInt64Dictionary alloc] init];
506           break;
507         case GPBDataTypeInt64:
508         case GPBDataTypeSFixed64:
509         case GPBDataTypeSInt64:
510           result = [[GPBStringInt64Dictionary alloc] init];
511           break;
512         case GPBDataTypeFloat:
513           result = [[GPBStringFloatDictionary alloc] init];
514           break;
515         case GPBDataTypeDouble:
516           result = [[GPBStringDoubleDictionary alloc] init];
517           break;
518         case GPBDataTypeEnum:
519           result = [[GPBStringEnumDictionary alloc]
520               initWithValidationFunction:field.enumDescriptor.enumVerifier];
521           break;
522         case GPBDataTypeBytes:
523         case GPBDataTypeMessage:
524         case GPBDataTypeString:
525           if (autocreator) {
526             result = [[GPBAutocreatedDictionary alloc] init];
527           } else {
528             result = [[NSMutableDictionary alloc] init];
529           }
530           break;
531         case GPBDataTypeGroup:
532           NSCAssert(NO, @"shouldn't happen");
533           return nil;
534       }
535       break;
536
537     case GPBDataTypeFloat:
538     case GPBDataTypeDouble:
539     case GPBDataTypeEnum:
540     case GPBDataTypeBytes:
541     case GPBDataTypeGroup:
542     case GPBDataTypeMessage:
543       NSCAssert(NO, @"shouldn't happen");
544       return nil;
545   }
546
547   if (autocreator) {
548     if ((keyDataType == GPBDataTypeString) &&
549         GPBDataTypeIsObject(valueDataType)) {
550       GPBAutocreatedDictionary *autoDict = result;
551       autoDict->_autocreator =  autocreator;
552     } else {
553       GPBInt32Int32Dictionary *gpbDict = result;
554       gpbDict->_autocreator = autocreator;
555     }
556   }
557
558   return result;
559 }
560
561 #if !defined(__clang_analyzer__)
562 // These functions are blocked from the analyzer because the analyzer sees the
563 // GPBSetRetainedObjectIvarWithFieldInternal() call as consuming the array/map,
564 // so use of the array/map after the call returns is flagged as a use after
565 // free.
566 // But GPBSetRetainedObjectIvarWithFieldInternal() is "consuming" the retain
567 // count be holding onto the object (it is transfering it), the object is
568 // still valid after returning from the call.  The other way to avoid this
569 // would be to add a -retain/-autorelease, but that would force every
570 // repeated/map field parsed into the autorelease pool which is both a memory
571 // and performance hit.
572
573 static id GetOrCreateArrayIvarWithField(GPBMessage *self,
574                                         GPBFieldDescriptor *field,
575                                         GPBFileSyntax syntax) {
576   id array = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
577   if (!array) {
578     // No lock needed, this is called from places expecting to mutate
579     // so no threading protection is needed.
580     array = CreateArrayForField(field, nil);
581     GPBSetRetainedObjectIvarWithFieldInternal(self, field, array, syntax);
582   }
583   return array;
584 }
585
586 // This is like GPBGetObjectIvarWithField(), but for arrays, it should
587 // only be used to wire the method into the class.
588 static id GetArrayIvarWithField(GPBMessage *self, GPBFieldDescriptor *field) {
589   id array = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
590   if (!array) {
591     // Check again after getting the lock.
592     GPBPrepareReadOnlySemaphore(self);
593     dispatch_semaphore_wait(self->readOnlySemaphore_, DISPATCH_TIME_FOREVER);
594     array = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
595     if (!array) {
596       array = CreateArrayForField(field, self);
597       GPBSetAutocreatedRetainedObjectIvarWithField(self, field, array);
598     }
599     dispatch_semaphore_signal(self->readOnlySemaphore_);
600   }
601   return array;
602 }
603
604 static id GetOrCreateMapIvarWithField(GPBMessage *self,
605                                       GPBFieldDescriptor *field,
606                                       GPBFileSyntax syntax) {
607   id dict = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
608   if (!dict) {
609     // No lock needed, this is called from places expecting to mutate
610     // so no threading protection is needed.
611     dict = CreateMapForField(field, nil);
612     GPBSetRetainedObjectIvarWithFieldInternal(self, field, dict, syntax);
613   }
614   return dict;
615 }
616
617 // This is like GPBGetObjectIvarWithField(), but for maps, it should
618 // only be used to wire the method into the class.
619 static id GetMapIvarWithField(GPBMessage *self, GPBFieldDescriptor *field) {
620   id dict = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
621   if (!dict) {
622     // Check again after getting the lock.
623     GPBPrepareReadOnlySemaphore(self);
624     dispatch_semaphore_wait(self->readOnlySemaphore_, DISPATCH_TIME_FOREVER);
625     dict = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
626     if (!dict) {
627       dict = CreateMapForField(field, self);
628       GPBSetAutocreatedRetainedObjectIvarWithField(self, field, dict);
629     }
630     dispatch_semaphore_signal(self->readOnlySemaphore_);
631   }
632   return dict;
633 }
634
635 #endif  // !defined(__clang_analyzer__)
636
637 GPBMessage *GPBCreateMessageWithAutocreator(Class msgClass,
638                                             GPBMessage *autocreator,
639                                             GPBFieldDescriptor *field) {
640   GPBMessage *message = [[msgClass alloc] init];
641   message->autocreator_ = autocreator;
642   message->autocreatorField_ = [field retain];
643   return message;
644 }
645
646 static GPBMessage *CreateMessageWithAutocreatorForExtension(
647     Class msgClass, GPBMessage *autocreator, GPBExtensionDescriptor *extension)
648     __attribute__((ns_returns_retained));
649
650 static GPBMessage *CreateMessageWithAutocreatorForExtension(
651     Class msgClass, GPBMessage *autocreator,
652     GPBExtensionDescriptor *extension) {
653   GPBMessage *message = [[msgClass alloc] init];
654   message->autocreator_ = autocreator;
655   message->autocreatorExtension_ = [extension retain];
656   return message;
657 }
658
659 BOOL GPBWasMessageAutocreatedBy(GPBMessage *message, GPBMessage *parent) {
660   return (message->autocreator_ == parent);
661 }
662
663 void GPBBecomeVisibleToAutocreator(GPBMessage *self) {
664   // Message objects that are implicitly created by accessing a message field
665   // are initially not visible via the hasX selector. This method makes them
666   // visible.
667   if (self->autocreator_) {
668     // This will recursively make all parent messages visible until it reaches a
669     // super-creator that's visible.
670     if (self->autocreatorField_) {
671       GPBFileSyntax syntax = [self->autocreator_ descriptor].file.syntax;
672       GPBSetObjectIvarWithFieldInternal(self->autocreator_,
673                                         self->autocreatorField_, self, syntax);
674     } else {
675       [self->autocreator_ setExtension:self->autocreatorExtension_ value:self];
676     }
677   }
678 }
679
680 void GPBAutocreatedArrayModified(GPBMessage *self, id array) {
681   // When one of our autocreated arrays adds elements, make it visible.
682   GPBDescriptor *descriptor = [[self class] descriptor];
683   for (GPBFieldDescriptor *field in descriptor->fields_) {
684     if (field.fieldType == GPBFieldTypeRepeated) {
685       id curArray = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
686       if (curArray == array) {
687         if (GPBFieldDataTypeIsObject(field)) {
688           GPBAutocreatedArray *autoArray = array;
689           autoArray->_autocreator = nil;
690         } else {
691           GPBInt32Array *gpbArray = array;
692           gpbArray->_autocreator = nil;
693         }
694         GPBBecomeVisibleToAutocreator(self);
695         return;
696       }
697     }
698   }
699   NSCAssert(NO, @"Unknown autocreated %@ for %@.", [array class], self);
700 }
701
702 void GPBAutocreatedDictionaryModified(GPBMessage *self, id dictionary) {
703   // When one of our autocreated dicts adds elements, make it visible.
704   GPBDescriptor *descriptor = [[self class] descriptor];
705   for (GPBFieldDescriptor *field in descriptor->fields_) {
706     if (field.fieldType == GPBFieldTypeMap) {
707       id curDict = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
708       if (curDict == dictionary) {
709         if ((field.mapKeyDataType == GPBDataTypeString) &&
710             GPBFieldDataTypeIsObject(field)) {
711           GPBAutocreatedDictionary *autoDict = dictionary;
712           autoDict->_autocreator = nil;
713         } else {
714           GPBInt32Int32Dictionary *gpbDict = dictionary;
715           gpbDict->_autocreator = nil;
716         }
717         GPBBecomeVisibleToAutocreator(self);
718         return;
719       }
720     }
721   }
722   NSCAssert(NO, @"Unknown autocreated %@ for %@.", [dictionary class], self);
723 }
724
725 void GPBClearMessageAutocreator(GPBMessage *self) {
726   if ((self == nil) || !self->autocreator_) {
727     return;
728   }
729
730 #if defined(DEBUG) && DEBUG && !defined(NS_BLOCK_ASSERTIONS)
731   // Either the autocreator must have its "has" flag set to YES, or it must be
732   // NO and not equal to ourselves.
733   BOOL autocreatorHas =
734       (self->autocreatorField_
735            ? GPBGetHasIvarField(self->autocreator_, self->autocreatorField_)
736            : [self->autocreator_ hasExtension:self->autocreatorExtension_]);
737   GPBMessage *autocreatorFieldValue =
738       (self->autocreatorField_
739            ? GPBGetObjectIvarWithFieldNoAutocreate(self->autocreator_,
740                                                    self->autocreatorField_)
741            : [self->autocreator_->autocreatedExtensionMap_
742                  objectForKey:self->autocreatorExtension_]);
743   NSCAssert(autocreatorHas || autocreatorFieldValue != self,
744             @"Cannot clear autocreator because it still refers to self, self: %@.",
745             self);
746
747 #endif  // DEBUG && !defined(NS_BLOCK_ASSERTIONS)
748
749   self->autocreator_ = nil;
750   [self->autocreatorField_ release];
751   self->autocreatorField_ = nil;
752   [self->autocreatorExtension_ release];
753   self->autocreatorExtension_ = nil;
754 }
755
756 // Call this before using the readOnlySemaphore_. This ensures it is created only once.
757 void GPBPrepareReadOnlySemaphore(GPBMessage *self) {
758 #pragma clang diagnostic push
759 #pragma clang diagnostic ignored "-Wdirect-ivar-access"
760
761   // Create the semaphore on demand (rather than init) as developers might not cause them
762   // to be needed, and the heap usage can add up.  The atomic swap is used to avoid needing
763   // another lock around creating it.
764   if (self->readOnlySemaphore_ == nil) {
765     dispatch_semaphore_t worker = dispatch_semaphore_create(1);
766     dispatch_semaphore_t expected = nil;
767     if (!atomic_compare_exchange_strong(&self->readOnlySemaphore_, &expected, worker)) {
768       dispatch_release(worker);
769     }
770 #if defined(__clang_analyzer__)
771     // The Xcode 9.2 (and 9.3 beta) static analyzer thinks worker is leaked
772     // (doesn't seem to know about atomic_compare_exchange_strong); so just
773     // for the analyzer, let it think worker is also released in this case.
774     else { dispatch_release(worker); }
775 #endif
776   }
777
778 #pragma clang diagnostic pop
779 }
780
781 static GPBUnknownFieldSet *GetOrMakeUnknownFields(GPBMessage *self) {
782   if (!self->unknownFields_) {
783     self->unknownFields_ = [[GPBUnknownFieldSet alloc] init];
784     GPBBecomeVisibleToAutocreator(self);
785   }
786   return self->unknownFields_;
787 }
788
789 @implementation GPBMessage
790
791 + (void)initialize {
792   Class pbMessageClass = [GPBMessage class];
793   if ([self class] == pbMessageClass) {
794     // This is here to start up the "base" class descriptor.
795     [self descriptor];
796     // Message shares extension method resolving with GPBRootObject so insure
797     // it is started up at the same time.
798     (void)[GPBRootObject class];
799   } else if ([self superclass] == pbMessageClass) {
800     // This is here to start up all the "message" subclasses. Just needs to be
801     // done for the messages, not any of the subclasses.
802     // This must be done in initialize to enforce thread safety of start up of
803     // the protocol buffer library.
804     // Note: The generated code for -descriptor calls
805     // +[GPBDescriptor allocDescriptorForClass:...], passing the GPBRootObject
806     // subclass for the file.  That call chain is what ensures that *Root class
807     // is started up to support extension resolution off the message class
808     // (+resolveClassMethod: below) in a thread safe manner.
809     [self descriptor];
810   }
811 }
812
813 + (instancetype)allocWithZone:(NSZone *)zone {
814   // Override alloc to allocate our classes with the additional storage
815   // required for the instance variables.
816   GPBDescriptor *descriptor = [self descriptor];
817   return NSAllocateObject(self, descriptor->storageSize_, zone);
818 }
819
820 + (instancetype)alloc {
821   return [self allocWithZone:nil];
822 }
823
824 + (GPBDescriptor *)descriptor {
825   // This is thread safe because it is called from +initialize.
826   static GPBDescriptor *descriptor = NULL;
827   static GPBFileDescriptor *fileDescriptor = NULL;
828   if (!descriptor) {
829     // Use a dummy file that marks it as proto2 syntax so when used generically
830     // it supports unknowns/etc.
831     fileDescriptor =
832         [[GPBFileDescriptor alloc] initWithPackage:@"internal"
833                                             syntax:GPBFileSyntaxProto2];
834
835     descriptor = [GPBDescriptor allocDescriptorForClass:[GPBMessage class]
836                                               rootClass:Nil
837                                                    file:fileDescriptor
838                                                  fields:NULL
839                                              fieldCount:0
840                                             storageSize:0
841                                                   flags:0];
842   }
843   return descriptor;
844 }
845
846 + (instancetype)message {
847   return [[[self alloc] init] autorelease];
848 }
849
850 - (instancetype)init {
851   if ((self = [super init])) {
852     messageStorage_ = (GPBMessage_StoragePtr)(
853         ((uint8_t *)self) + class_getInstanceSize([self class]));
854   }
855
856   return self;
857 }
858
859 - (instancetype)initWithData:(NSData *)data error:(NSError **)errorPtr {
860   return [self initWithData:data extensionRegistry:nil error:errorPtr];
861 }
862
863 - (instancetype)initWithData:(NSData *)data
864            extensionRegistry:(GPBExtensionRegistry *)extensionRegistry
865                        error:(NSError **)errorPtr {
866   if ((self = [self init])) {
867     @try {
868       [self mergeFromData:data extensionRegistry:extensionRegistry];
869       if (errorPtr) {
870         *errorPtr = nil;
871       }
872     }
873     @catch (NSException *exception) {
874       [self release];
875       self = nil;
876       if (errorPtr) {
877         *errorPtr = ErrorFromException(exception);
878       }
879     }
880 #ifdef DEBUG
881     if (self && !self.initialized) {
882       [self release];
883       self = nil;
884       if (errorPtr) {
885         *errorPtr = MessageError(GPBMessageErrorCodeMissingRequiredField, nil);
886       }
887     }
888 #endif
889   }
890   return self;
891 }
892
893 - (instancetype)initWithCodedInputStream:(GPBCodedInputStream *)input
894                        extensionRegistry:
895                            (GPBExtensionRegistry *)extensionRegistry
896                                    error:(NSError **)errorPtr {
897   if ((self = [self init])) {
898     @try {
899       [self mergeFromCodedInputStream:input extensionRegistry:extensionRegistry];
900       if (errorPtr) {
901         *errorPtr = nil;
902       }
903     }
904     @catch (NSException *exception) {
905       [self release];
906       self = nil;
907       if (errorPtr) {
908         *errorPtr = ErrorFromException(exception);
909       }
910     }
911 #ifdef DEBUG
912     if (self && !self.initialized) {
913       [self release];
914       self = nil;
915       if (errorPtr) {
916         *errorPtr = MessageError(GPBMessageErrorCodeMissingRequiredField, nil);
917       }
918     }
919 #endif
920   }
921   return self;
922 }
923
924 - (void)dealloc {
925   [self internalClear:NO];
926   NSCAssert(!autocreator_, @"Autocreator was not cleared before dealloc.");
927   if (readOnlySemaphore_) {
928     dispatch_release(readOnlySemaphore_);
929   }
930   [super dealloc];
931 }
932
933 - (void)copyFieldsInto:(GPBMessage *)message
934                   zone:(NSZone *)zone
935             descriptor:(GPBDescriptor *)descriptor {
936   // Copy all the storage...
937   memcpy(message->messageStorage_, messageStorage_, descriptor->storageSize_);
938
939   GPBFileSyntax syntax = descriptor.file.syntax;
940
941   // Loop over the fields doing fixup...
942   for (GPBFieldDescriptor *field in descriptor->fields_) {
943     if (GPBFieldIsMapOrArray(field)) {
944       id value = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
945       if (value) {
946         // We need to copy the array/map, but the catch is for message fields,
947         // we also need to ensure all the messages as those need copying also.
948         id newValue;
949         if (GPBFieldDataTypeIsMessage(field)) {
950           if (field.fieldType == GPBFieldTypeRepeated) {
951             NSArray *existingArray = (NSArray *)value;
952             NSMutableArray *newArray =
953                 [[NSMutableArray alloc] initWithCapacity:existingArray.count];
954             newValue = newArray;
955             for (GPBMessage *msg in existingArray) {
956               GPBMessage *copiedMsg = [msg copyWithZone:zone];
957               [newArray addObject:copiedMsg];
958               [copiedMsg release];
959             }
960           } else {
961             if (field.mapKeyDataType == GPBDataTypeString) {
962               // Map is an NSDictionary.
963               NSDictionary *existingDict = value;
964               NSMutableDictionary *newDict = [[NSMutableDictionary alloc]
965                   initWithCapacity:existingDict.count];
966               newValue = newDict;
967               [existingDict enumerateKeysAndObjectsUsingBlock:^(NSString *key,
968                                                                 GPBMessage *msg,
969                                                                 BOOL *stop) {
970 #pragma unused(stop)
971                 GPBMessage *copiedMsg = [msg copyWithZone:zone];
972                 [newDict setObject:copiedMsg forKey:key];
973                 [copiedMsg release];
974               }];
975             } else {
976               // Is one of the GPB*ObjectDictionary classes.  Type doesn't
977               // matter, just need one to invoke the selector.
978               GPBInt32ObjectDictionary *existingDict = value;
979               newValue = [existingDict deepCopyWithZone:zone];
980             }
981           }
982         } else {
983           // Not messages (but is a map/array)...
984           if (field.fieldType == GPBFieldTypeRepeated) {
985             if (GPBFieldDataTypeIsObject(field)) {
986               // NSArray
987               newValue = [value mutableCopyWithZone:zone];
988             } else {
989               // GPB*Array
990               newValue = [value copyWithZone:zone];
991             }
992           } else {
993             if ((field.mapKeyDataType == GPBDataTypeString) &&
994                 GPBFieldDataTypeIsObject(field)) {
995               // NSDictionary
996               newValue = [value mutableCopyWithZone:zone];
997             } else {
998               // Is one of the GPB*Dictionary classes.  Type doesn't matter,
999               // just need one to invoke the selector.
1000               GPBInt32Int32Dictionary *existingDict = value;
1001               newValue = [existingDict copyWithZone:zone];
1002             }
1003           }
1004         }
1005         // We retain here because the memcpy picked up the pointer value and
1006         // the next call to SetRetainedObject... will release the current value.
1007         [value retain];
1008         GPBSetRetainedObjectIvarWithFieldInternal(message, field, newValue,
1009                                                   syntax);
1010       }
1011     } else if (GPBFieldDataTypeIsMessage(field)) {
1012       // For object types, if we have a value, copy it.  If we don't,
1013       // zero it to remove the pointer to something that was autocreated
1014       // (and the ptr just got memcpyed).
1015       if (GPBGetHasIvarField(self, field)) {
1016         GPBMessage *value = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1017         GPBMessage *newValue = [value copyWithZone:zone];
1018         // We retain here because the memcpy picked up the pointer value and
1019         // the next call to SetRetainedObject... will release the current value.
1020         [value retain];
1021         GPBSetRetainedObjectIvarWithFieldInternal(message, field, newValue,
1022                                                   syntax);
1023       } else {
1024         uint8_t *storage = (uint8_t *)message->messageStorage_;
1025         id *typePtr = (id *)&storage[field->description_->offset];
1026         *typePtr = NULL;
1027       }
1028     } else if (GPBFieldDataTypeIsObject(field) &&
1029                GPBGetHasIvarField(self, field)) {
1030       // A set string/data value (message picked off above), copy it.
1031       id value = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1032       id newValue = [value copyWithZone:zone];
1033       // We retain here because the memcpy picked up the pointer value and
1034       // the next call to SetRetainedObject... will release the current value.
1035       [value retain];
1036       GPBSetRetainedObjectIvarWithFieldInternal(message, field, newValue,
1037                                                 syntax);
1038     } else {
1039       // memcpy took care of the rest of the primitive fields if they were set.
1040     }
1041   }  // for (field in descriptor->fields_)
1042 }
1043
1044 - (id)copyWithZone:(NSZone *)zone {
1045   GPBDescriptor *descriptor = [self descriptor];
1046   GPBMessage *result = [[descriptor.messageClass allocWithZone:zone] init];
1047
1048   [self copyFieldsInto:result zone:zone descriptor:descriptor];
1049   // Make immutable copies of the extra bits.
1050   result->unknownFields_ = [unknownFields_ copyWithZone:zone];
1051   result->extensionMap_ = CloneExtensionMap(extensionMap_, zone);
1052   return result;
1053 }
1054
1055 - (void)clear {
1056   [self internalClear:YES];
1057 }
1058
1059 - (void)internalClear:(BOOL)zeroStorage {
1060   GPBDescriptor *descriptor = [self descriptor];
1061   for (GPBFieldDescriptor *field in descriptor->fields_) {
1062     if (GPBFieldIsMapOrArray(field)) {
1063       id arrayOrMap = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1064       if (arrayOrMap) {
1065         if (field.fieldType == GPBFieldTypeRepeated) {
1066           if (GPBFieldDataTypeIsObject(field)) {
1067             if ([arrayOrMap isKindOfClass:[GPBAutocreatedArray class]]) {
1068               GPBAutocreatedArray *autoArray = arrayOrMap;
1069               if (autoArray->_autocreator == self) {
1070                 autoArray->_autocreator = nil;
1071               }
1072             }
1073           } else {
1074             // Type doesn't matter, it is a GPB*Array.
1075             GPBInt32Array *gpbArray = arrayOrMap;
1076             if (gpbArray->_autocreator == self) {
1077               gpbArray->_autocreator = nil;
1078             }
1079           }
1080         } else {
1081           if ((field.mapKeyDataType == GPBDataTypeString) &&
1082               GPBFieldDataTypeIsObject(field)) {
1083             if ([arrayOrMap isKindOfClass:[GPBAutocreatedDictionary class]]) {
1084               GPBAutocreatedDictionary *autoDict = arrayOrMap;
1085               if (autoDict->_autocreator == self) {
1086                 autoDict->_autocreator = nil;
1087               }
1088             }
1089           } else {
1090             // Type doesn't matter, it is a GPB*Dictionary.
1091             GPBInt32Int32Dictionary *gpbDict = arrayOrMap;
1092             if (gpbDict->_autocreator == self) {
1093               gpbDict->_autocreator = nil;
1094             }
1095           }
1096         }
1097         [arrayOrMap release];
1098       }
1099     } else if (GPBFieldDataTypeIsMessage(field)) {
1100       GPBClearAutocreatedMessageIvarWithField(self, field);
1101       GPBMessage *value = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1102       [value release];
1103     } else if (GPBFieldDataTypeIsObject(field) &&
1104                GPBGetHasIvarField(self, field)) {
1105       id value = GPBGetObjectIvarWithField(self, field);
1106       [value release];
1107     }
1108   }
1109
1110   // GPBClearMessageAutocreator() expects that its caller has already been
1111   // removed from autocreatedExtensionMap_ so we set to nil first.
1112   NSArray *autocreatedValues = [autocreatedExtensionMap_ allValues];
1113   [autocreatedExtensionMap_ release];
1114   autocreatedExtensionMap_ = nil;
1115
1116   // Since we're clearing all of our extensions, make sure that we clear the
1117   // autocreator on any that we've created so they no longer refer to us.
1118   for (GPBMessage *value in autocreatedValues) {
1119     NSCAssert(GPBWasMessageAutocreatedBy(value, self),
1120               @"Autocreated extension does not refer back to self.");
1121     GPBClearMessageAutocreator(value);
1122   }
1123
1124   [extensionMap_ release];
1125   extensionMap_ = nil;
1126   [unknownFields_ release];
1127   unknownFields_ = nil;
1128
1129   // Note that clearing does not affect autocreator_. If we are being cleared
1130   // because of a dealloc, then autocreator_ should be nil anyway. If we are
1131   // being cleared because someone explicitly clears us, we don't want to
1132   // sever our relationship with our autocreator.
1133
1134   if (zeroStorage) {
1135     memset(messageStorage_, 0, descriptor->storageSize_);
1136   }
1137 }
1138
1139 - (BOOL)isInitialized {
1140   GPBDescriptor *descriptor = [self descriptor];
1141   for (GPBFieldDescriptor *field in descriptor->fields_) {
1142     if (field.isRequired) {
1143       if (!GPBGetHasIvarField(self, field)) {
1144         return NO;
1145       }
1146     }
1147     if (GPBFieldDataTypeIsMessage(field)) {
1148       GPBFieldType fieldType = field.fieldType;
1149       if (fieldType == GPBFieldTypeSingle) {
1150         if (field.isRequired) {
1151           GPBMessage *message = GPBGetMessageMessageField(self, field);
1152           if (!message.initialized) {
1153             return NO;
1154           }
1155         } else {
1156           NSAssert(field.isOptional,
1157                    @"%@: Single message field %@ not required or optional?",
1158                    [self class], field.name);
1159           if (GPBGetHasIvarField(self, field)) {
1160             GPBMessage *message = GPBGetMessageMessageField(self, field);
1161             if (!message.initialized) {
1162               return NO;
1163             }
1164           }
1165         }
1166       } else if (fieldType == GPBFieldTypeRepeated) {
1167         NSArray *array = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1168         for (GPBMessage *message in array) {
1169           if (!message.initialized) {
1170             return NO;
1171           }
1172         }
1173       } else {  // fieldType == GPBFieldTypeMap
1174         if (field.mapKeyDataType == GPBDataTypeString) {
1175           NSDictionary *map =
1176               GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1177           if (map && !GPBDictionaryIsInitializedInternalHelper(map, field)) {
1178             return NO;
1179           }
1180         } else {
1181           // Real type is GPB*ObjectDictionary, exact type doesn't matter.
1182           GPBInt32ObjectDictionary *map =
1183               GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1184           if (map && ![map isInitialized]) {
1185             return NO;
1186           }
1187         }
1188       }
1189     }
1190   }
1191
1192   __block BOOL result = YES;
1193   [extensionMap_
1194       enumerateKeysAndObjectsUsingBlock:^(GPBExtensionDescriptor *extension,
1195                                           id obj,
1196                                           BOOL *stop) {
1197         if (GPBExtensionIsMessage(extension)) {
1198           if (extension.isRepeated) {
1199             for (GPBMessage *msg in obj) {
1200               if (!msg.initialized) {
1201                 result = NO;
1202                 *stop = YES;
1203                 break;
1204               }
1205             }
1206           } else {
1207             GPBMessage *asMsg = obj;
1208             if (!asMsg.initialized) {
1209               result = NO;
1210               *stop = YES;
1211             }
1212           }
1213         }
1214       }];
1215   return result;
1216 }
1217
1218 - (GPBDescriptor *)descriptor {
1219   return [[self class] descriptor];
1220 }
1221
1222 - (NSData *)data {
1223 #ifdef DEBUG
1224   if (!self.initialized) {
1225     return nil;
1226   }
1227 #endif
1228   NSMutableData *data = [NSMutableData dataWithLength:[self serializedSize]];
1229   GPBCodedOutputStream *stream =
1230       [[GPBCodedOutputStream alloc] initWithData:data];
1231   @try {
1232     [self writeToCodedOutputStream:stream];
1233   }
1234   @catch (NSException *exception) {
1235     // This really shouldn't happen. The only way writeToCodedOutputStream:
1236     // could throw is if something in the library has a bug and the
1237     // serializedSize was wrong.
1238 #ifdef DEBUG
1239     NSLog(@"%@: Internal exception while building message data: %@",
1240           [self class], exception);
1241 #endif
1242     data = nil;
1243   }
1244   [stream release];
1245   return data;
1246 }
1247
1248 - (NSData *)delimitedData {
1249   size_t serializedSize = [self serializedSize];
1250   size_t varintSize = GPBComputeRawVarint32SizeForInteger(serializedSize);
1251   NSMutableData *data =
1252       [NSMutableData dataWithLength:(serializedSize + varintSize)];
1253   GPBCodedOutputStream *stream =
1254       [[GPBCodedOutputStream alloc] initWithData:data];
1255   @try {
1256     [self writeDelimitedToCodedOutputStream:stream];
1257   }
1258   @catch (NSException *exception) {
1259     // This really shouldn't happen.  The only way writeToCodedOutputStream:
1260     // could throw is if something in the library has a bug and the
1261     // serializedSize was wrong.
1262 #ifdef DEBUG
1263     NSLog(@"%@: Internal exception while building message delimitedData: %@",
1264           [self class], exception);
1265 #endif
1266     // If it happens, truncate.
1267     data.length = 0;
1268   }
1269   [stream release];
1270   return data;
1271 }
1272
1273 - (void)writeToOutputStream:(NSOutputStream *)output {
1274   GPBCodedOutputStream *stream =
1275       [[GPBCodedOutputStream alloc] initWithOutputStream:output];
1276   [self writeToCodedOutputStream:stream];
1277   [stream release];
1278 }
1279
1280 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)output {
1281   GPBDescriptor *descriptor = [self descriptor];
1282   NSArray *fieldsArray = descriptor->fields_;
1283   NSUInteger fieldCount = fieldsArray.count;
1284   const GPBExtensionRange *extensionRanges = descriptor.extensionRanges;
1285   NSUInteger extensionRangesCount = descriptor.extensionRangesCount;
1286   for (NSUInteger i = 0, j = 0; i < fieldCount || j < extensionRangesCount;) {
1287     if (i == fieldCount) {
1288       [self writeExtensionsToCodedOutputStream:output
1289                                          range:extensionRanges[j++]];
1290     } else if (j == extensionRangesCount ||
1291                GPBFieldNumber(fieldsArray[i]) < extensionRanges[j].start) {
1292       [self writeField:fieldsArray[i++] toCodedOutputStream:output];
1293     } else {
1294       [self writeExtensionsToCodedOutputStream:output
1295                                          range:extensionRanges[j++]];
1296     }
1297   }
1298   if (descriptor.isWireFormat) {
1299     [unknownFields_ writeAsMessageSetTo:output];
1300   } else {
1301     [unknownFields_ writeToCodedOutputStream:output];
1302   }
1303 }
1304
1305 - (void)writeDelimitedToOutputStream:(NSOutputStream *)output {
1306   GPBCodedOutputStream *codedOutput =
1307       [[GPBCodedOutputStream alloc] initWithOutputStream:output];
1308   [self writeDelimitedToCodedOutputStream:codedOutput];
1309   [codedOutput release];
1310 }
1311
1312 - (void)writeDelimitedToCodedOutputStream:(GPBCodedOutputStream *)output {
1313   [output writeRawVarintSizeTAs32:[self serializedSize]];
1314   [self writeToCodedOutputStream:output];
1315 }
1316
1317 - (void)writeField:(GPBFieldDescriptor *)field
1318     toCodedOutputStream:(GPBCodedOutputStream *)output {
1319   GPBFieldType fieldType = field.fieldType;
1320   if (fieldType == GPBFieldTypeSingle) {
1321     BOOL has = GPBGetHasIvarField(self, field);
1322     if (!has) {
1323       return;
1324     }
1325   }
1326   uint32_t fieldNumber = GPBFieldNumber(field);
1327
1328 //%PDDM-DEFINE FIELD_CASE(TYPE, REAL_TYPE)
1329 //%FIELD_CASE_FULL(TYPE, REAL_TYPE, REAL_TYPE)
1330 //%PDDM-DEFINE FIELD_CASE_FULL(TYPE, REAL_TYPE, ARRAY_TYPE)
1331 //%    case GPBDataType##TYPE:
1332 //%      if (fieldType == GPBFieldTypeRepeated) {
1333 //%        uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
1334 //%        GPB##ARRAY_TYPE##Array *array =
1335 //%            GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1336 //%        [output write##TYPE##Array:fieldNumber values:array tag:tag];
1337 //%      } else if (fieldType == GPBFieldTypeSingle) {
1338 //%        [output write##TYPE:fieldNumber
1339 //%              TYPE$S  value:GPBGetMessage##REAL_TYPE##Field(self, field)];
1340 //%      } else {  // fieldType == GPBFieldTypeMap
1341 //%        // Exact type here doesn't matter.
1342 //%        GPBInt32##ARRAY_TYPE##Dictionary *dict =
1343 //%            GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1344 //%        [dict writeToCodedOutputStream:output asField:field];
1345 //%      }
1346 //%      break;
1347 //%
1348 //%PDDM-DEFINE FIELD_CASE2(TYPE)
1349 //%    case GPBDataType##TYPE:
1350 //%      if (fieldType == GPBFieldTypeRepeated) {
1351 //%        NSArray *array = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1352 //%        [output write##TYPE##Array:fieldNumber values:array];
1353 //%      } else if (fieldType == GPBFieldTypeSingle) {
1354 //%        // GPBGetObjectIvarWithFieldNoAutocreate() avoids doing the has check
1355 //%        // again.
1356 //%        [output write##TYPE:fieldNumber
1357 //%              TYPE$S  value:GPBGetObjectIvarWithFieldNoAutocreate(self, field)];
1358 //%      } else {  // fieldType == GPBFieldTypeMap
1359 //%        // Exact type here doesn't matter.
1360 //%        id dict = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1361 //%        GPBDataType mapKeyDataType = field.mapKeyDataType;
1362 //%        if (mapKeyDataType == GPBDataTypeString) {
1363 //%          GPBDictionaryWriteToStreamInternalHelper(output, dict, field);
1364 //%        } else {
1365 //%          [dict writeToCodedOutputStream:output asField:field];
1366 //%        }
1367 //%      }
1368 //%      break;
1369 //%
1370
1371   switch (GPBGetFieldDataType(field)) {
1372
1373 //%PDDM-EXPAND FIELD_CASE(Bool, Bool)
1374 // This block of code is generated, do not edit it directly.
1375
1376     case GPBDataTypeBool:
1377       if (fieldType == GPBFieldTypeRepeated) {
1378         uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
1379         GPBBoolArray *array =
1380             GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1381         [output writeBoolArray:fieldNumber values:array tag:tag];
1382       } else if (fieldType == GPBFieldTypeSingle) {
1383         [output writeBool:fieldNumber
1384                     value:GPBGetMessageBoolField(self, field)];
1385       } else {  // fieldType == GPBFieldTypeMap
1386         // Exact type here doesn't matter.
1387         GPBInt32BoolDictionary *dict =
1388             GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1389         [dict writeToCodedOutputStream:output asField:field];
1390       }
1391       break;
1392
1393 //%PDDM-EXPAND FIELD_CASE(Fixed32, UInt32)
1394 // This block of code is generated, do not edit it directly.
1395
1396     case GPBDataTypeFixed32:
1397       if (fieldType == GPBFieldTypeRepeated) {
1398         uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
1399         GPBUInt32Array *array =
1400             GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1401         [output writeFixed32Array:fieldNumber values:array tag:tag];
1402       } else if (fieldType == GPBFieldTypeSingle) {
1403         [output writeFixed32:fieldNumber
1404                        value:GPBGetMessageUInt32Field(self, field)];
1405       } else {  // fieldType == GPBFieldTypeMap
1406         // Exact type here doesn't matter.
1407         GPBInt32UInt32Dictionary *dict =
1408             GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1409         [dict writeToCodedOutputStream:output asField:field];
1410       }
1411       break;
1412
1413 //%PDDM-EXPAND FIELD_CASE(SFixed32, Int32)
1414 // This block of code is generated, do not edit it directly.
1415
1416     case GPBDataTypeSFixed32:
1417       if (fieldType == GPBFieldTypeRepeated) {
1418         uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
1419         GPBInt32Array *array =
1420             GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1421         [output writeSFixed32Array:fieldNumber values:array tag:tag];
1422       } else if (fieldType == GPBFieldTypeSingle) {
1423         [output writeSFixed32:fieldNumber
1424                         value:GPBGetMessageInt32Field(self, field)];
1425       } else {  // fieldType == GPBFieldTypeMap
1426         // Exact type here doesn't matter.
1427         GPBInt32Int32Dictionary *dict =
1428             GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1429         [dict writeToCodedOutputStream:output asField:field];
1430       }
1431       break;
1432
1433 //%PDDM-EXPAND FIELD_CASE(Float, Float)
1434 // This block of code is generated, do not edit it directly.
1435
1436     case GPBDataTypeFloat:
1437       if (fieldType == GPBFieldTypeRepeated) {
1438         uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
1439         GPBFloatArray *array =
1440             GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1441         [output writeFloatArray:fieldNumber values:array tag:tag];
1442       } else if (fieldType == GPBFieldTypeSingle) {
1443         [output writeFloat:fieldNumber
1444                      value:GPBGetMessageFloatField(self, field)];
1445       } else {  // fieldType == GPBFieldTypeMap
1446         // Exact type here doesn't matter.
1447         GPBInt32FloatDictionary *dict =
1448             GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1449         [dict writeToCodedOutputStream:output asField:field];
1450       }
1451       break;
1452
1453 //%PDDM-EXPAND FIELD_CASE(Fixed64, UInt64)
1454 // This block of code is generated, do not edit it directly.
1455
1456     case GPBDataTypeFixed64:
1457       if (fieldType == GPBFieldTypeRepeated) {
1458         uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
1459         GPBUInt64Array *array =
1460             GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1461         [output writeFixed64Array:fieldNumber values:array tag:tag];
1462       } else if (fieldType == GPBFieldTypeSingle) {
1463         [output writeFixed64:fieldNumber
1464                        value:GPBGetMessageUInt64Field(self, field)];
1465       } else {  // fieldType == GPBFieldTypeMap
1466         // Exact type here doesn't matter.
1467         GPBInt32UInt64Dictionary *dict =
1468             GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1469         [dict writeToCodedOutputStream:output asField:field];
1470       }
1471       break;
1472
1473 //%PDDM-EXPAND FIELD_CASE(SFixed64, Int64)
1474 // This block of code is generated, do not edit it directly.
1475
1476     case GPBDataTypeSFixed64:
1477       if (fieldType == GPBFieldTypeRepeated) {
1478         uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
1479         GPBInt64Array *array =
1480             GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1481         [output writeSFixed64Array:fieldNumber values:array tag:tag];
1482       } else if (fieldType == GPBFieldTypeSingle) {
1483         [output writeSFixed64:fieldNumber
1484                         value:GPBGetMessageInt64Field(self, field)];
1485       } else {  // fieldType == GPBFieldTypeMap
1486         // Exact type here doesn't matter.
1487         GPBInt32Int64Dictionary *dict =
1488             GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1489         [dict writeToCodedOutputStream:output asField:field];
1490       }
1491       break;
1492
1493 //%PDDM-EXPAND FIELD_CASE(Double, Double)
1494 // This block of code is generated, do not edit it directly.
1495
1496     case GPBDataTypeDouble:
1497       if (fieldType == GPBFieldTypeRepeated) {
1498         uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
1499         GPBDoubleArray *array =
1500             GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1501         [output writeDoubleArray:fieldNumber values:array tag:tag];
1502       } else if (fieldType == GPBFieldTypeSingle) {
1503         [output writeDouble:fieldNumber
1504                       value:GPBGetMessageDoubleField(self, field)];
1505       } else {  // fieldType == GPBFieldTypeMap
1506         // Exact type here doesn't matter.
1507         GPBInt32DoubleDictionary *dict =
1508             GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1509         [dict writeToCodedOutputStream:output asField:field];
1510       }
1511       break;
1512
1513 //%PDDM-EXPAND FIELD_CASE(Int32, Int32)
1514 // This block of code is generated, do not edit it directly.
1515
1516     case GPBDataTypeInt32:
1517       if (fieldType == GPBFieldTypeRepeated) {
1518         uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
1519         GPBInt32Array *array =
1520             GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1521         [output writeInt32Array:fieldNumber values:array tag:tag];
1522       } else if (fieldType == GPBFieldTypeSingle) {
1523         [output writeInt32:fieldNumber
1524                      value:GPBGetMessageInt32Field(self, field)];
1525       } else {  // fieldType == GPBFieldTypeMap
1526         // Exact type here doesn't matter.
1527         GPBInt32Int32Dictionary *dict =
1528             GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1529         [dict writeToCodedOutputStream:output asField:field];
1530       }
1531       break;
1532
1533 //%PDDM-EXPAND FIELD_CASE(Int64, Int64)
1534 // This block of code is generated, do not edit it directly.
1535
1536     case GPBDataTypeInt64:
1537       if (fieldType == GPBFieldTypeRepeated) {
1538         uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
1539         GPBInt64Array *array =
1540             GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1541         [output writeInt64Array:fieldNumber values:array tag:tag];
1542       } else if (fieldType == GPBFieldTypeSingle) {
1543         [output writeInt64:fieldNumber
1544                      value:GPBGetMessageInt64Field(self, field)];
1545       } else {  // fieldType == GPBFieldTypeMap
1546         // Exact type here doesn't matter.
1547         GPBInt32Int64Dictionary *dict =
1548             GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1549         [dict writeToCodedOutputStream:output asField:field];
1550       }
1551       break;
1552
1553 //%PDDM-EXPAND FIELD_CASE(SInt32, Int32)
1554 // This block of code is generated, do not edit it directly.
1555
1556     case GPBDataTypeSInt32:
1557       if (fieldType == GPBFieldTypeRepeated) {
1558         uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
1559         GPBInt32Array *array =
1560             GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1561         [output writeSInt32Array:fieldNumber values:array tag:tag];
1562       } else if (fieldType == GPBFieldTypeSingle) {
1563         [output writeSInt32:fieldNumber
1564                       value:GPBGetMessageInt32Field(self, field)];
1565       } else {  // fieldType == GPBFieldTypeMap
1566         // Exact type here doesn't matter.
1567         GPBInt32Int32Dictionary *dict =
1568             GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1569         [dict writeToCodedOutputStream:output asField:field];
1570       }
1571       break;
1572
1573 //%PDDM-EXPAND FIELD_CASE(SInt64, Int64)
1574 // This block of code is generated, do not edit it directly.
1575
1576     case GPBDataTypeSInt64:
1577       if (fieldType == GPBFieldTypeRepeated) {
1578         uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
1579         GPBInt64Array *array =
1580             GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1581         [output writeSInt64Array:fieldNumber values:array tag:tag];
1582       } else if (fieldType == GPBFieldTypeSingle) {
1583         [output writeSInt64:fieldNumber
1584                       value:GPBGetMessageInt64Field(self, field)];
1585       } else {  // fieldType == GPBFieldTypeMap
1586         // Exact type here doesn't matter.
1587         GPBInt32Int64Dictionary *dict =
1588             GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1589         [dict writeToCodedOutputStream:output asField:field];
1590       }
1591       break;
1592
1593 //%PDDM-EXPAND FIELD_CASE(UInt32, UInt32)
1594 // This block of code is generated, do not edit it directly.
1595
1596     case GPBDataTypeUInt32:
1597       if (fieldType == GPBFieldTypeRepeated) {
1598         uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
1599         GPBUInt32Array *array =
1600             GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1601         [output writeUInt32Array:fieldNumber values:array tag:tag];
1602       } else if (fieldType == GPBFieldTypeSingle) {
1603         [output writeUInt32:fieldNumber
1604                       value:GPBGetMessageUInt32Field(self, field)];
1605       } else {  // fieldType == GPBFieldTypeMap
1606         // Exact type here doesn't matter.
1607         GPBInt32UInt32Dictionary *dict =
1608             GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1609         [dict writeToCodedOutputStream:output asField:field];
1610       }
1611       break;
1612
1613 //%PDDM-EXPAND FIELD_CASE(UInt64, UInt64)
1614 // This block of code is generated, do not edit it directly.
1615
1616     case GPBDataTypeUInt64:
1617       if (fieldType == GPBFieldTypeRepeated) {
1618         uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
1619         GPBUInt64Array *array =
1620             GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1621         [output writeUInt64Array:fieldNumber values:array tag:tag];
1622       } else if (fieldType == GPBFieldTypeSingle) {
1623         [output writeUInt64:fieldNumber
1624                       value:GPBGetMessageUInt64Field(self, field)];
1625       } else {  // fieldType == GPBFieldTypeMap
1626         // Exact type here doesn't matter.
1627         GPBInt32UInt64Dictionary *dict =
1628             GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1629         [dict writeToCodedOutputStream:output asField:field];
1630       }
1631       break;
1632
1633 //%PDDM-EXPAND FIELD_CASE_FULL(Enum, Int32, Enum)
1634 // This block of code is generated, do not edit it directly.
1635
1636     case GPBDataTypeEnum:
1637       if (fieldType == GPBFieldTypeRepeated) {
1638         uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
1639         GPBEnumArray *array =
1640             GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1641         [output writeEnumArray:fieldNumber values:array tag:tag];
1642       } else if (fieldType == GPBFieldTypeSingle) {
1643         [output writeEnum:fieldNumber
1644                     value:GPBGetMessageInt32Field(self, field)];
1645       } else {  // fieldType == GPBFieldTypeMap
1646         // Exact type here doesn't matter.
1647         GPBInt32EnumDictionary *dict =
1648             GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1649         [dict writeToCodedOutputStream:output asField:field];
1650       }
1651       break;
1652
1653 //%PDDM-EXPAND FIELD_CASE2(Bytes)
1654 // This block of code is generated, do not edit it directly.
1655
1656     case GPBDataTypeBytes:
1657       if (fieldType == GPBFieldTypeRepeated) {
1658         NSArray *array = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1659         [output writeBytesArray:fieldNumber values:array];
1660       } else if (fieldType == GPBFieldTypeSingle) {
1661         // GPBGetObjectIvarWithFieldNoAutocreate() avoids doing the has check
1662         // again.
1663         [output writeBytes:fieldNumber
1664                      value:GPBGetObjectIvarWithFieldNoAutocreate(self, field)];
1665       } else {  // fieldType == GPBFieldTypeMap
1666         // Exact type here doesn't matter.
1667         id dict = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1668         GPBDataType mapKeyDataType = field.mapKeyDataType;
1669         if (mapKeyDataType == GPBDataTypeString) {
1670           GPBDictionaryWriteToStreamInternalHelper(output, dict, field);
1671         } else {
1672           [dict writeToCodedOutputStream:output asField:field];
1673         }
1674       }
1675       break;
1676
1677 //%PDDM-EXPAND FIELD_CASE2(String)
1678 // This block of code is generated, do not edit it directly.
1679
1680     case GPBDataTypeString:
1681       if (fieldType == GPBFieldTypeRepeated) {
1682         NSArray *array = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1683         [output writeStringArray:fieldNumber values:array];
1684       } else if (fieldType == GPBFieldTypeSingle) {
1685         // GPBGetObjectIvarWithFieldNoAutocreate() avoids doing the has check
1686         // again.
1687         [output writeString:fieldNumber
1688                       value:GPBGetObjectIvarWithFieldNoAutocreate(self, field)];
1689       } else {  // fieldType == GPBFieldTypeMap
1690         // Exact type here doesn't matter.
1691         id dict = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1692         GPBDataType mapKeyDataType = field.mapKeyDataType;
1693         if (mapKeyDataType == GPBDataTypeString) {
1694           GPBDictionaryWriteToStreamInternalHelper(output, dict, field);
1695         } else {
1696           [dict writeToCodedOutputStream:output asField:field];
1697         }
1698       }
1699       break;
1700
1701 //%PDDM-EXPAND FIELD_CASE2(Message)
1702 // This block of code is generated, do not edit it directly.
1703
1704     case GPBDataTypeMessage:
1705       if (fieldType == GPBFieldTypeRepeated) {
1706         NSArray *array = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1707         [output writeMessageArray:fieldNumber values:array];
1708       } else if (fieldType == GPBFieldTypeSingle) {
1709         // GPBGetObjectIvarWithFieldNoAutocreate() avoids doing the has check
1710         // again.
1711         [output writeMessage:fieldNumber
1712                        value:GPBGetObjectIvarWithFieldNoAutocreate(self, field)];
1713       } else {  // fieldType == GPBFieldTypeMap
1714         // Exact type here doesn't matter.
1715         id dict = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1716         GPBDataType mapKeyDataType = field.mapKeyDataType;
1717         if (mapKeyDataType == GPBDataTypeString) {
1718           GPBDictionaryWriteToStreamInternalHelper(output, dict, field);
1719         } else {
1720           [dict writeToCodedOutputStream:output asField:field];
1721         }
1722       }
1723       break;
1724
1725 //%PDDM-EXPAND FIELD_CASE2(Group)
1726 // This block of code is generated, do not edit it directly.
1727
1728     case GPBDataTypeGroup:
1729       if (fieldType == GPBFieldTypeRepeated) {
1730         NSArray *array = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1731         [output writeGroupArray:fieldNumber values:array];
1732       } else if (fieldType == GPBFieldTypeSingle) {
1733         // GPBGetObjectIvarWithFieldNoAutocreate() avoids doing the has check
1734         // again.
1735         [output writeGroup:fieldNumber
1736                      value:GPBGetObjectIvarWithFieldNoAutocreate(self, field)];
1737       } else {  // fieldType == GPBFieldTypeMap
1738         // Exact type here doesn't matter.
1739         id dict = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
1740         GPBDataType mapKeyDataType = field.mapKeyDataType;
1741         if (mapKeyDataType == GPBDataTypeString) {
1742           GPBDictionaryWriteToStreamInternalHelper(output, dict, field);
1743         } else {
1744           [dict writeToCodedOutputStream:output asField:field];
1745         }
1746       }
1747       break;
1748
1749 //%PDDM-EXPAND-END (18 expansions)
1750   }
1751 }
1752
1753 #pragma mark - Extensions
1754
1755 - (id)getExtension:(GPBExtensionDescriptor *)extension {
1756   CheckExtension(self, extension);
1757   id value = [extensionMap_ objectForKey:extension];
1758   if (value != nil) {
1759     return value;
1760   }
1761
1762   // No default for repeated.
1763   if (extension.isRepeated) {
1764     return nil;
1765   }
1766   // Non messages get their default.
1767   if (!GPBExtensionIsMessage(extension)) {
1768     return extension.defaultValue;
1769   }
1770
1771   // Check for an autocreated value.
1772   GPBPrepareReadOnlySemaphore(self);
1773   dispatch_semaphore_wait(readOnlySemaphore_, DISPATCH_TIME_FOREVER);
1774   value = [autocreatedExtensionMap_ objectForKey:extension];
1775   if (!value) {
1776     // Auto create the message extensions to match normal fields.
1777     value = CreateMessageWithAutocreatorForExtension(extension.msgClass, self,
1778                                                      extension);
1779
1780     if (autocreatedExtensionMap_ == nil) {
1781       autocreatedExtensionMap_ = [[NSMutableDictionary alloc] init];
1782     }
1783
1784     // We can't simply call setExtension here because that would clear the new
1785     // value's autocreator.
1786     [autocreatedExtensionMap_ setObject:value forKey:extension];
1787     [value release];
1788   }
1789
1790   dispatch_semaphore_signal(readOnlySemaphore_);
1791   return value;
1792 }
1793
1794 - (id)getExistingExtension:(GPBExtensionDescriptor *)extension {
1795   // This is an internal method so we don't need to call CheckExtension().
1796   return [extensionMap_ objectForKey:extension];
1797 }
1798
1799 - (BOOL)hasExtension:(GPBExtensionDescriptor *)extension {
1800 #if defined(DEBUG) && DEBUG
1801   CheckExtension(self, extension);
1802 #endif  // DEBUG
1803   return nil != [extensionMap_ objectForKey:extension];
1804 }
1805
1806 - (NSArray *)extensionsCurrentlySet {
1807   return [extensionMap_ allKeys];
1808 }
1809
1810 - (void)writeExtensionsToCodedOutputStream:(GPBCodedOutputStream *)output
1811                                      range:(GPBExtensionRange)range {
1812   NSArray *sortedExtensions = [[extensionMap_ allKeys]
1813       sortedArrayUsingSelector:@selector(compareByFieldNumber:)];
1814   uint32_t start = range.start;
1815   uint32_t end = range.end;
1816   for (GPBExtensionDescriptor *extension in sortedExtensions) {
1817     uint32_t fieldNumber = extension.fieldNumber;
1818     if (fieldNumber >= start && fieldNumber < end) {
1819       id value = [extensionMap_ objectForKey:extension];
1820       GPBWriteExtensionValueToOutputStream(extension, value, output);
1821     }
1822   }
1823 }
1824
1825 - (void)setExtension:(GPBExtensionDescriptor *)extension value:(id)value {
1826   if (!value) {
1827     [self clearExtension:extension];
1828     return;
1829   }
1830
1831   CheckExtension(self, extension);
1832
1833   if (extension.repeated) {
1834     [NSException raise:NSInvalidArgumentException
1835                 format:@"Must call addExtension() for repeated types."];
1836   }
1837
1838   if (extensionMap_ == nil) {
1839     extensionMap_ = [[NSMutableDictionary alloc] init];
1840   }
1841
1842   // This pointless cast is for CLANG_WARN_NULLABLE_TO_NONNULL_CONVERSION.
1843   // Without it, the compiler complains we're passing an id nullable when
1844   // setObject:forKey: requires a id nonnull for the value. The check for
1845   // !value at the start of the method ensures it isn't nil, but the check
1846   // isn't smart enough to realize that.
1847   [extensionMap_ setObject:(id)value forKey:extension];
1848
1849   GPBExtensionDescriptor *descriptor = extension;
1850
1851   if (GPBExtensionIsMessage(descriptor) && !descriptor.isRepeated) {
1852     GPBMessage *autocreatedValue =
1853         [[autocreatedExtensionMap_ objectForKey:extension] retain];
1854     // Must remove from the map before calling GPBClearMessageAutocreator() so
1855     // that GPBClearMessageAutocreator() knows its safe to clear.
1856     [autocreatedExtensionMap_ removeObjectForKey:extension];
1857     GPBClearMessageAutocreator(autocreatedValue);
1858     [autocreatedValue release];
1859   }
1860
1861   GPBBecomeVisibleToAutocreator(self);
1862 }
1863
1864 - (void)addExtension:(GPBExtensionDescriptor *)extension value:(id)value {
1865   CheckExtension(self, extension);
1866
1867   if (!extension.repeated) {
1868     [NSException raise:NSInvalidArgumentException
1869                 format:@"Must call setExtension() for singular types."];
1870   }
1871
1872   if (extensionMap_ == nil) {
1873     extensionMap_ = [[NSMutableDictionary alloc] init];
1874   }
1875   NSMutableArray *list = [extensionMap_ objectForKey:extension];
1876   if (list == nil) {
1877     list = [NSMutableArray array];
1878     [extensionMap_ setObject:list forKey:extension];
1879   }
1880
1881   [list addObject:value];
1882   GPBBecomeVisibleToAutocreator(self);
1883 }
1884
1885 - (void)setExtension:(GPBExtensionDescriptor *)extension
1886                index:(NSUInteger)idx
1887                value:(id)value {
1888   CheckExtension(self, extension);
1889
1890   if (!extension.repeated) {
1891     [NSException raise:NSInvalidArgumentException
1892                 format:@"Must call setExtension() for singular types."];
1893   }
1894
1895   if (extensionMap_ == nil) {
1896     extensionMap_ = [[NSMutableDictionary alloc] init];
1897   }
1898
1899   NSMutableArray *list = [extensionMap_ objectForKey:extension];
1900
1901   [list replaceObjectAtIndex:idx withObject:value];
1902   GPBBecomeVisibleToAutocreator(self);
1903 }
1904
1905 - (void)clearExtension:(GPBExtensionDescriptor *)extension {
1906   CheckExtension(self, extension);
1907
1908   // Only become visible if there was actually a value to clear.
1909   if ([extensionMap_ objectForKey:extension]) {
1910     [extensionMap_ removeObjectForKey:extension];
1911     GPBBecomeVisibleToAutocreator(self);
1912   }
1913 }
1914
1915 #pragma mark - mergeFrom
1916
1917 - (void)mergeFromData:(NSData *)data
1918     extensionRegistry:(GPBExtensionRegistry *)extensionRegistry {
1919   GPBCodedInputStream *input = [[GPBCodedInputStream alloc] initWithData:data];
1920   [self mergeFromCodedInputStream:input extensionRegistry:extensionRegistry];
1921   [input checkLastTagWas:0];
1922   [input release];
1923 }
1924
1925 #pragma mark - mergeDelimitedFrom
1926
1927 - (void)mergeDelimitedFromCodedInputStream:(GPBCodedInputStream *)input
1928                          extensionRegistry:(GPBExtensionRegistry *)extensionRegistry {
1929   GPBCodedInputStreamState *state = &input->state_;
1930   if (GPBCodedInputStreamIsAtEnd(state)) {
1931     return;
1932   }
1933   NSData *data = GPBCodedInputStreamReadRetainedBytesNoCopy(state);
1934   if (data == nil) {
1935     return;
1936   }
1937   [self mergeFromData:data extensionRegistry:extensionRegistry];
1938   [data release];
1939 }
1940
1941 #pragma mark - Parse From Data Support
1942
1943 + (instancetype)parseFromData:(NSData *)data error:(NSError **)errorPtr {
1944   return [self parseFromData:data extensionRegistry:nil error:errorPtr];
1945 }
1946
1947 + (instancetype)parseFromData:(NSData *)data
1948             extensionRegistry:(GPBExtensionRegistry *)extensionRegistry
1949                         error:(NSError **)errorPtr {
1950   return [[[self alloc] initWithData:data
1951                    extensionRegistry:extensionRegistry
1952                                error:errorPtr] autorelease];
1953 }
1954
1955 + (instancetype)parseFromCodedInputStream:(GPBCodedInputStream *)input
1956                         extensionRegistry:(GPBExtensionRegistry *)extensionRegistry
1957                                     error:(NSError **)errorPtr {
1958   return
1959       [[[self alloc] initWithCodedInputStream:input
1960                             extensionRegistry:extensionRegistry
1961                                         error:errorPtr] autorelease];
1962 }
1963
1964 #pragma mark - Parse Delimited From Data Support
1965
1966 + (instancetype)parseDelimitedFromCodedInputStream:(GPBCodedInputStream *)input
1967                                  extensionRegistry:
1968                                      (GPBExtensionRegistry *)extensionRegistry
1969                                              error:(NSError **)errorPtr {
1970   GPBMessage *message = [[[self alloc] init] autorelease];
1971   @try {
1972     [message mergeDelimitedFromCodedInputStream:input
1973                               extensionRegistry:extensionRegistry];
1974     if (errorPtr) {
1975       *errorPtr = nil;
1976     }
1977   }
1978   @catch (NSException *exception) {
1979     message = nil;
1980     if (errorPtr) {
1981       *errorPtr = ErrorFromException(exception);
1982     }
1983   }
1984 #ifdef DEBUG
1985   if (message && !message.initialized) {
1986     message = nil;
1987     if (errorPtr) {
1988       *errorPtr = MessageError(GPBMessageErrorCodeMissingRequiredField, nil);
1989     }
1990   }
1991 #endif
1992   return message;
1993 }
1994
1995 #pragma mark - Unknown Field Support
1996
1997 - (GPBUnknownFieldSet *)unknownFields {
1998   return unknownFields_;
1999 }
2000
2001 - (void)setUnknownFields:(GPBUnknownFieldSet *)unknownFields {
2002   if (unknownFields != unknownFields_) {
2003     [unknownFields_ release];
2004     unknownFields_ = [unknownFields copy];
2005     GPBBecomeVisibleToAutocreator(self);
2006   }
2007 }
2008
2009 - (void)parseMessageSet:(GPBCodedInputStream *)input
2010       extensionRegistry:(GPBExtensionRegistry *)extensionRegistry {
2011   uint32_t typeId = 0;
2012   NSData *rawBytes = nil;
2013   GPBExtensionDescriptor *extension = nil;
2014   GPBCodedInputStreamState *state = &input->state_;
2015   while (true) {
2016     uint32_t tag = GPBCodedInputStreamReadTag(state);
2017     if (tag == 0) {
2018       break;
2019     }
2020
2021     if (tag == GPBWireFormatMessageSetTypeIdTag) {
2022       typeId = GPBCodedInputStreamReadUInt32(state);
2023       if (typeId != 0) {
2024         extension = [extensionRegistry extensionForDescriptor:[self descriptor]
2025                                                   fieldNumber:typeId];
2026       }
2027     } else if (tag == GPBWireFormatMessageSetMessageTag) {
2028       rawBytes =
2029           [GPBCodedInputStreamReadRetainedBytesNoCopy(state) autorelease];
2030     } else {
2031       if (![input skipField:tag]) {
2032         break;
2033       }
2034     }
2035   }
2036
2037   [input checkLastTagWas:GPBWireFormatMessageSetItemEndTag];
2038
2039   if (rawBytes != nil && typeId != 0) {
2040     if (extension != nil) {
2041       GPBCodedInputStream *newInput =
2042           [[GPBCodedInputStream alloc] initWithData:rawBytes];
2043       GPBExtensionMergeFromInputStream(extension,
2044                                        extension.packable,
2045                                        newInput,
2046                                        extensionRegistry,
2047                                        self);
2048       [newInput release];
2049     } else {
2050       GPBUnknownFieldSet *unknownFields = GetOrMakeUnknownFields(self);
2051       // rawBytes was created via a NoCopy, so it can be reusing a
2052       // subrange of another NSData that might go out of scope as things
2053       // unwind, so a copy is needed to ensure what is saved in the
2054       // unknown fields stays valid.
2055       NSData *cloned = [NSData dataWithData:rawBytes];
2056       [unknownFields mergeMessageSetMessage:typeId data:cloned];
2057     }
2058   }
2059 }
2060
2061 - (BOOL)parseUnknownField:(GPBCodedInputStream *)input
2062         extensionRegistry:(GPBExtensionRegistry *)extensionRegistry
2063                       tag:(uint32_t)tag {
2064   GPBWireFormat wireType = GPBWireFormatGetTagWireType(tag);
2065   int32_t fieldNumber = GPBWireFormatGetTagFieldNumber(tag);
2066
2067   GPBDescriptor *descriptor = [self descriptor];
2068   GPBExtensionDescriptor *extension =
2069       [extensionRegistry extensionForDescriptor:descriptor
2070                                     fieldNumber:fieldNumber];
2071   if (extension == nil) {
2072     if (descriptor.wireFormat && GPBWireFormatMessageSetItemTag == tag) {
2073       [self parseMessageSet:input extensionRegistry:extensionRegistry];
2074       return YES;
2075     }
2076   } else {
2077     if (extension.wireType == wireType) {
2078       GPBExtensionMergeFromInputStream(extension,
2079                                        extension.packable,
2080                                        input,
2081                                        extensionRegistry,
2082                                        self);
2083       return YES;
2084     }
2085     // Primitive, repeated types can be packed on unpacked on the wire, and are
2086     // parsed either way.
2087     if ([extension isRepeated] &&
2088         !GPBDataTypeIsObject(extension->description_->dataType) &&
2089         (extension.alternateWireType == wireType)) {
2090       GPBExtensionMergeFromInputStream(extension,
2091                                        !extension.packable,
2092                                        input,
2093                                        extensionRegistry,
2094                                        self);
2095       return YES;
2096     }
2097   }
2098   if ([GPBUnknownFieldSet isFieldTag:tag]) {
2099     GPBUnknownFieldSet *unknownFields = GetOrMakeUnknownFields(self);
2100     return [unknownFields mergeFieldFrom:tag input:input];
2101   } else {
2102     return NO;
2103   }
2104 }
2105
2106 - (void)addUnknownMapEntry:(int32_t)fieldNum value:(NSData *)data {
2107   GPBUnknownFieldSet *unknownFields = GetOrMakeUnknownFields(self);
2108   [unknownFields addUnknownMapEntry:fieldNum value:data];
2109 }
2110
2111 #pragma mark - MergeFromCodedInputStream Support
2112
2113 static void MergeSingleFieldFromCodedInputStream(
2114     GPBMessage *self, GPBFieldDescriptor *field, GPBFileSyntax syntax,
2115     GPBCodedInputStream *input, GPBExtensionRegistry *extensionRegistry) {
2116   GPBDataType fieldDataType = GPBGetFieldDataType(field);
2117   switch (fieldDataType) {
2118 #define CASE_SINGLE_POD(NAME, TYPE, FUNC_TYPE)                             \
2119     case GPBDataType##NAME: {                                              \
2120       TYPE val = GPBCodedInputStreamRead##NAME(&input->state_);            \
2121       GPBSet##FUNC_TYPE##IvarWithFieldInternal(self, field, val, syntax);  \
2122       break;                                                               \
2123             }
2124 #define CASE_SINGLE_OBJECT(NAME)                                           \
2125     case GPBDataType##NAME: {                                              \
2126       id val = GPBCodedInputStreamReadRetained##NAME(&input->state_);      \
2127       GPBSetRetainedObjectIvarWithFieldInternal(self, field, val, syntax); \
2128       break;                                                               \
2129     }
2130       CASE_SINGLE_POD(Bool, BOOL, Bool)
2131       CASE_SINGLE_POD(Fixed32, uint32_t, UInt32)
2132       CASE_SINGLE_POD(SFixed32, int32_t, Int32)
2133       CASE_SINGLE_POD(Float, float, Float)
2134       CASE_SINGLE_POD(Fixed64, uint64_t, UInt64)
2135       CASE_SINGLE_POD(SFixed64, int64_t, Int64)
2136       CASE_SINGLE_POD(Double, double, Double)
2137       CASE_SINGLE_POD(Int32, int32_t, Int32)
2138       CASE_SINGLE_POD(Int64, int64_t, Int64)
2139       CASE_SINGLE_POD(SInt32, int32_t, Int32)
2140       CASE_SINGLE_POD(SInt64, int64_t, Int64)
2141       CASE_SINGLE_POD(UInt32, uint32_t, UInt32)
2142       CASE_SINGLE_POD(UInt64, uint64_t, UInt64)
2143       CASE_SINGLE_OBJECT(Bytes)
2144       CASE_SINGLE_OBJECT(String)
2145 #undef CASE_SINGLE_POD
2146 #undef CASE_SINGLE_OBJECT
2147
2148     case GPBDataTypeMessage: {
2149       if (GPBGetHasIvarField(self, field)) {
2150         // GPBGetObjectIvarWithFieldNoAutocreate() avoids doing the has
2151         // check again.
2152         GPBMessage *message =
2153             GPBGetObjectIvarWithFieldNoAutocreate(self, field);
2154         [input readMessage:message extensionRegistry:extensionRegistry];
2155       } else {
2156         GPBMessage *message = [[field.msgClass alloc] init];
2157         [input readMessage:message extensionRegistry:extensionRegistry];
2158         GPBSetRetainedObjectIvarWithFieldInternal(self, field, message, syntax);
2159       }
2160       break;
2161     }
2162
2163     case GPBDataTypeGroup: {
2164       if (GPBGetHasIvarField(self, field)) {
2165         // GPBGetObjectIvarWithFieldNoAutocreate() avoids doing the has
2166         // check again.
2167         GPBMessage *message =
2168             GPBGetObjectIvarWithFieldNoAutocreate(self, field);
2169         [input readGroup:GPBFieldNumber(field)
2170                       message:message
2171             extensionRegistry:extensionRegistry];
2172       } else {
2173         GPBMessage *message = [[field.msgClass alloc] init];
2174         [input readGroup:GPBFieldNumber(field)
2175                       message:message
2176             extensionRegistry:extensionRegistry];
2177         GPBSetRetainedObjectIvarWithFieldInternal(self, field, message, syntax);
2178       }
2179       break;
2180     }
2181
2182     case GPBDataTypeEnum: {
2183       int32_t val = GPBCodedInputStreamReadEnum(&input->state_);
2184       if (GPBHasPreservingUnknownEnumSemantics(syntax) ||
2185           [field isValidEnumValue:val]) {
2186         GPBSetInt32IvarWithFieldInternal(self, field, val, syntax);
2187       } else {
2188         GPBUnknownFieldSet *unknownFields = GetOrMakeUnknownFields(self);
2189         [unknownFields mergeVarintField:GPBFieldNumber(field) value:val];
2190       }
2191     }
2192   }  // switch
2193 }
2194
2195 static void MergeRepeatedPackedFieldFromCodedInputStream(
2196     GPBMessage *self, GPBFieldDescriptor *field, GPBFileSyntax syntax,
2197     GPBCodedInputStream *input) {
2198   GPBDataType fieldDataType = GPBGetFieldDataType(field);
2199   GPBCodedInputStreamState *state = &input->state_;
2200   id genericArray = GetOrCreateArrayIvarWithField(self, field, syntax);
2201   int32_t length = GPBCodedInputStreamReadInt32(state);
2202   size_t limit = GPBCodedInputStreamPushLimit(state, length);
2203   while (GPBCodedInputStreamBytesUntilLimit(state) > 0) {
2204     switch (fieldDataType) {
2205 #define CASE_REPEATED_PACKED_POD(NAME, TYPE, ARRAY_TYPE)      \
2206      case GPBDataType##NAME: {                                \
2207        TYPE val = GPBCodedInputStreamRead##NAME(state);       \
2208        [(GPB##ARRAY_TYPE##Array *)genericArray addValue:val]; \
2209        break;                                                 \
2210      }
2211         CASE_REPEATED_PACKED_POD(Bool, BOOL, Bool)
2212         CASE_REPEATED_PACKED_POD(Fixed32, uint32_t, UInt32)
2213         CASE_REPEATED_PACKED_POD(SFixed32, int32_t, Int32)
2214         CASE_REPEATED_PACKED_POD(Float, float, Float)
2215         CASE_REPEATED_PACKED_POD(Fixed64, uint64_t, UInt64)
2216         CASE_REPEATED_PACKED_POD(SFixed64, int64_t, Int64)
2217         CASE_REPEATED_PACKED_POD(Double, double, Double)
2218         CASE_REPEATED_PACKED_POD(Int32, int32_t, Int32)
2219         CASE_REPEATED_PACKED_POD(Int64, int64_t, Int64)
2220         CASE_REPEATED_PACKED_POD(SInt32, int32_t, Int32)
2221         CASE_REPEATED_PACKED_POD(SInt64, int64_t, Int64)
2222         CASE_REPEATED_PACKED_POD(UInt32, uint32_t, UInt32)
2223         CASE_REPEATED_PACKED_POD(UInt64, uint64_t, UInt64)
2224 #undef CASE_REPEATED_PACKED_POD
2225
2226       case GPBDataTypeBytes:
2227       case GPBDataTypeString:
2228       case GPBDataTypeMessage:
2229       case GPBDataTypeGroup:
2230         NSCAssert(NO, @"Non primitive types can't be packed");
2231         break;
2232
2233       case GPBDataTypeEnum: {
2234         int32_t val = GPBCodedInputStreamReadEnum(state);
2235         if (GPBHasPreservingUnknownEnumSemantics(syntax) ||
2236             [field isValidEnumValue:val]) {
2237           [(GPBEnumArray*)genericArray addRawValue:val];
2238         } else {
2239           GPBUnknownFieldSet *unknownFields = GetOrMakeUnknownFields(self);
2240           [unknownFields mergeVarintField:GPBFieldNumber(field) value:val];
2241         }
2242         break;
2243       }
2244     }  // switch
2245   }  // while(BytesUntilLimit() > 0)
2246   GPBCodedInputStreamPopLimit(state, limit);
2247 }
2248
2249 static void MergeRepeatedNotPackedFieldFromCodedInputStream(
2250     GPBMessage *self, GPBFieldDescriptor *field, GPBFileSyntax syntax,
2251     GPBCodedInputStream *input, GPBExtensionRegistry *extensionRegistry) {
2252   GPBCodedInputStreamState *state = &input->state_;
2253   id genericArray = GetOrCreateArrayIvarWithField(self, field, syntax);
2254   switch (GPBGetFieldDataType(field)) {
2255 #define CASE_REPEATED_NOT_PACKED_POD(NAME, TYPE, ARRAY_TYPE) \
2256    case GPBDataType##NAME: {                                 \
2257      TYPE val = GPBCodedInputStreamRead##NAME(state);        \
2258      [(GPB##ARRAY_TYPE##Array *)genericArray addValue:val];  \
2259      break;                                                  \
2260    }
2261 #define CASE_REPEATED_NOT_PACKED_OBJECT(NAME)                \
2262    case GPBDataType##NAME: {                                 \
2263      id val = GPBCodedInputStreamReadRetained##NAME(state);  \
2264      [(NSMutableArray*)genericArray addObject:val];          \
2265      [val release];                                          \
2266      break;                                                  \
2267    }
2268       CASE_REPEATED_NOT_PACKED_POD(Bool, BOOL, Bool)
2269       CASE_REPEATED_NOT_PACKED_POD(Fixed32, uint32_t, UInt32)
2270       CASE_REPEATED_NOT_PACKED_POD(SFixed32, int32_t, Int32)
2271       CASE_REPEATED_NOT_PACKED_POD(Float, float, Float)
2272       CASE_REPEATED_NOT_PACKED_POD(Fixed64, uint64_t, UInt64)
2273       CASE_REPEATED_NOT_PACKED_POD(SFixed64, int64_t, Int64)
2274       CASE_REPEATED_NOT_PACKED_POD(Double, double, Double)
2275       CASE_REPEATED_NOT_PACKED_POD(Int32, int32_t, Int32)
2276       CASE_REPEATED_NOT_PACKED_POD(Int64, int64_t, Int64)
2277       CASE_REPEATED_NOT_PACKED_POD(SInt32, int32_t, Int32)
2278       CASE_REPEATED_NOT_PACKED_POD(SInt64, int64_t, Int64)
2279       CASE_REPEATED_NOT_PACKED_POD(UInt32, uint32_t, UInt32)
2280       CASE_REPEATED_NOT_PACKED_POD(UInt64, uint64_t, UInt64)
2281       CASE_REPEATED_NOT_PACKED_OBJECT(Bytes)
2282       CASE_REPEATED_NOT_PACKED_OBJECT(String)
2283 #undef CASE_REPEATED_NOT_PACKED_POD
2284 #undef CASE_NOT_PACKED_OBJECT
2285     case GPBDataTypeMessage: {
2286       GPBMessage *message = [[field.msgClass alloc] init];
2287       [input readMessage:message extensionRegistry:extensionRegistry];
2288       [(NSMutableArray*)genericArray addObject:message];
2289       [message release];
2290       break;
2291     }
2292     case GPBDataTypeGroup: {
2293       GPBMessage *message = [[field.msgClass alloc] init];
2294       [input readGroup:GPBFieldNumber(field)
2295                     message:message
2296           extensionRegistry:extensionRegistry];
2297       [(NSMutableArray*)genericArray addObject:message];
2298       [message release];
2299       break;
2300     }
2301     case GPBDataTypeEnum: {
2302       int32_t val = GPBCodedInputStreamReadEnum(state);
2303       if (GPBHasPreservingUnknownEnumSemantics(syntax) ||
2304           [field isValidEnumValue:val]) {
2305         [(GPBEnumArray*)genericArray addRawValue:val];
2306       } else {
2307         GPBUnknownFieldSet *unknownFields = GetOrMakeUnknownFields(self);
2308         [unknownFields mergeVarintField:GPBFieldNumber(field) value:val];
2309       }
2310       break;
2311     }
2312   }  // switch
2313 }
2314
2315 - (void)mergeFromCodedInputStream:(GPBCodedInputStream *)input
2316                 extensionRegistry:(GPBExtensionRegistry *)extensionRegistry {
2317   GPBDescriptor *descriptor = [self descriptor];
2318   GPBFileSyntax syntax = descriptor.file.syntax;
2319   GPBCodedInputStreamState *state = &input->state_;
2320   uint32_t tag = 0;
2321   NSUInteger startingIndex = 0;
2322   NSArray *fields = descriptor->fields_;
2323   NSUInteger numFields = fields.count;
2324   while (YES) {
2325     BOOL merged = NO;
2326     tag = GPBCodedInputStreamReadTag(state);
2327     if (tag == 0) {
2328       break;  // Reached end.
2329     }
2330     for (NSUInteger i = 0; i < numFields; ++i) {
2331       if (startingIndex >= numFields) startingIndex = 0;
2332       GPBFieldDescriptor *fieldDescriptor = fields[startingIndex];
2333       if (GPBFieldTag(fieldDescriptor) == tag) {
2334         GPBFieldType fieldType = fieldDescriptor.fieldType;
2335         if (fieldType == GPBFieldTypeSingle) {
2336           MergeSingleFieldFromCodedInputStream(self, fieldDescriptor, syntax,
2337                                                input, extensionRegistry);
2338           // Well formed protos will only have a single field once, advance
2339           // the starting index to the next field.
2340           startingIndex += 1;
2341         } else if (fieldType == GPBFieldTypeRepeated) {
2342           if (fieldDescriptor.isPackable) {
2343             MergeRepeatedPackedFieldFromCodedInputStream(
2344                 self, fieldDescriptor, syntax, input);
2345             // Well formed protos will only have a repeated field that is
2346             // packed once, advance the starting index to the next field.
2347             startingIndex += 1;
2348           } else {
2349             MergeRepeatedNotPackedFieldFromCodedInputStream(
2350                 self, fieldDescriptor, syntax, input, extensionRegistry);
2351           }
2352         } else {  // fieldType == GPBFieldTypeMap
2353           // GPB*Dictionary or NSDictionary, exact type doesn't matter at this
2354           // point.
2355           id map = GetOrCreateMapIvarWithField(self, fieldDescriptor, syntax);
2356           [input readMapEntry:map
2357             extensionRegistry:extensionRegistry
2358                         field:fieldDescriptor
2359                 parentMessage:self];
2360         }
2361         merged = YES;
2362         break;
2363       } else {
2364         startingIndex += 1;
2365       }
2366     }  // for(i < numFields)
2367
2368     if (!merged && (tag != 0)) {
2369       // Primitive, repeated types can be packed on unpacked on the wire, and
2370       // are parsed either way.  The above loop covered tag in the preferred
2371       // for, so this need to check the alternate form.
2372       for (NSUInteger i = 0; i < numFields; ++i) {
2373         if (startingIndex >= numFields) startingIndex = 0;
2374         GPBFieldDescriptor *fieldDescriptor = fields[startingIndex];
2375         if ((fieldDescriptor.fieldType == GPBFieldTypeRepeated) &&
2376             !GPBFieldDataTypeIsObject(fieldDescriptor) &&
2377             (GPBFieldAlternateTag(fieldDescriptor) == tag)) {
2378           BOOL alternateIsPacked = !fieldDescriptor.isPackable;
2379           if (alternateIsPacked) {
2380             MergeRepeatedPackedFieldFromCodedInputStream(
2381                 self, fieldDescriptor, syntax, input);
2382             // Well formed protos will only have a repeated field that is
2383             // packed once, advance the starting index to the next field.
2384             startingIndex += 1;
2385           } else {
2386             MergeRepeatedNotPackedFieldFromCodedInputStream(
2387                 self, fieldDescriptor, syntax, input, extensionRegistry);
2388           }
2389           merged = YES;
2390           break;
2391         } else {
2392           startingIndex += 1;
2393         }
2394       }
2395     }
2396
2397     if (!merged) {
2398       if (tag == 0) {
2399         // zero signals EOF / limit reached
2400         return;
2401       } else {
2402         if (![self parseUnknownField:input
2403                    extensionRegistry:extensionRegistry
2404                                  tag:tag]) {
2405           // it's an endgroup tag
2406           return;
2407         }
2408       }
2409     }  // if(!merged)
2410
2411   }  // while(YES)
2412 }
2413
2414 #pragma mark - MergeFrom Support
2415
2416 - (void)mergeFrom:(GPBMessage *)other {
2417   Class selfClass = [self class];
2418   Class otherClass = [other class];
2419   if (!([selfClass isSubclassOfClass:otherClass] ||
2420         [otherClass isSubclassOfClass:selfClass])) {
2421     [NSException raise:NSInvalidArgumentException
2422                 format:@"Classes must match %@ != %@", selfClass, otherClass];
2423   }
2424
2425   // We assume something will be done and become visible.
2426   GPBBecomeVisibleToAutocreator(self);
2427
2428   GPBDescriptor *descriptor = [[self class] descriptor];
2429   GPBFileSyntax syntax = descriptor.file.syntax;
2430
2431   for (GPBFieldDescriptor *field in descriptor->fields_) {
2432     GPBFieldType fieldType = field.fieldType;
2433     if (fieldType == GPBFieldTypeSingle) {
2434       int32_t hasIndex = GPBFieldHasIndex(field);
2435       uint32_t fieldNumber = GPBFieldNumber(field);
2436       if (!GPBGetHasIvar(other, hasIndex, fieldNumber)) {
2437         // Other doesn't have the field set, on to the next.
2438         continue;
2439       }
2440       GPBDataType fieldDataType = GPBGetFieldDataType(field);
2441       switch (fieldDataType) {
2442         case GPBDataTypeBool:
2443           GPBSetBoolIvarWithFieldInternal(
2444               self, field, GPBGetMessageBoolField(other, field), syntax);
2445           break;
2446         case GPBDataTypeSFixed32:
2447         case GPBDataTypeEnum:
2448         case GPBDataTypeInt32:
2449         case GPBDataTypeSInt32:
2450           GPBSetInt32IvarWithFieldInternal(
2451               self, field, GPBGetMessageInt32Field(other, field), syntax);
2452           break;
2453         case GPBDataTypeFixed32:
2454         case GPBDataTypeUInt32:
2455           GPBSetUInt32IvarWithFieldInternal(
2456               self, field, GPBGetMessageUInt32Field(other, field), syntax);
2457           break;
2458         case GPBDataTypeSFixed64:
2459         case GPBDataTypeInt64:
2460         case GPBDataTypeSInt64:
2461           GPBSetInt64IvarWithFieldInternal(
2462               self, field, GPBGetMessageInt64Field(other, field), syntax);
2463           break;
2464         case GPBDataTypeFixed64:
2465         case GPBDataTypeUInt64:
2466           GPBSetUInt64IvarWithFieldInternal(
2467               self, field, GPBGetMessageUInt64Field(other, field), syntax);
2468           break;
2469         case GPBDataTypeFloat:
2470           GPBSetFloatIvarWithFieldInternal(
2471               self, field, GPBGetMessageFloatField(other, field), syntax);
2472           break;
2473         case GPBDataTypeDouble:
2474           GPBSetDoubleIvarWithFieldInternal(
2475               self, field, GPBGetMessageDoubleField(other, field), syntax);
2476           break;
2477         case GPBDataTypeBytes:
2478         case GPBDataTypeString: {
2479           id otherVal = GPBGetObjectIvarWithFieldNoAutocreate(other, field);
2480           GPBSetObjectIvarWithFieldInternal(self, field, otherVal, syntax);
2481           break;
2482         }
2483         case GPBDataTypeMessage:
2484         case GPBDataTypeGroup: {
2485           id otherVal = GPBGetObjectIvarWithFieldNoAutocreate(other, field);
2486           if (GPBGetHasIvar(self, hasIndex, fieldNumber)) {
2487             GPBMessage *message =
2488                 GPBGetObjectIvarWithFieldNoAutocreate(self, field);
2489             [message mergeFrom:otherVal];
2490           } else {
2491             GPBMessage *message = [otherVal copy];
2492             GPBSetRetainedObjectIvarWithFieldInternal(self, field, message,
2493                                                       syntax);
2494           }
2495           break;
2496         }
2497       } // switch()
2498     } else if (fieldType == GPBFieldTypeRepeated) {
2499       // In the case of a list, they need to be appended, and there is no
2500       // _hasIvar to worry about setting.
2501       id otherArray =
2502           GPBGetObjectIvarWithFieldNoAutocreate(other, field);
2503       if (otherArray) {
2504         GPBDataType fieldDataType = field->description_->dataType;
2505         if (GPBDataTypeIsObject(fieldDataType)) {
2506           NSMutableArray *resultArray =
2507               GetOrCreateArrayIvarWithField(self, field, syntax);
2508           [resultArray addObjectsFromArray:otherArray];
2509         } else if (fieldDataType == GPBDataTypeEnum) {
2510           GPBEnumArray *resultArray =
2511               GetOrCreateArrayIvarWithField(self, field, syntax);
2512           [resultArray addRawValuesFromArray:otherArray];
2513         } else {
2514           // The array type doesn't matter, that all implment
2515           // -addValuesFromArray:.
2516           GPBInt32Array *resultArray =
2517               GetOrCreateArrayIvarWithField(self, field, syntax);
2518           [resultArray addValuesFromArray:otherArray];
2519         }
2520       }
2521     } else {  // fieldType = GPBFieldTypeMap
2522       // In the case of a map, they need to be merged, and there is no
2523       // _hasIvar to worry about setting.
2524       id otherDict = GPBGetObjectIvarWithFieldNoAutocreate(other, field);
2525       if (otherDict) {
2526         GPBDataType keyDataType = field.mapKeyDataType;
2527         GPBDataType valueDataType = field->description_->dataType;
2528         if (GPBDataTypeIsObject(keyDataType) &&
2529             GPBDataTypeIsObject(valueDataType)) {
2530           NSMutableDictionary *resultDict =
2531               GetOrCreateMapIvarWithField(self, field, syntax);
2532           [resultDict addEntriesFromDictionary:otherDict];
2533         } else if (valueDataType == GPBDataTypeEnum) {
2534           // The exact type doesn't matter, just need to know it is a
2535           // GPB*EnumDictionary.
2536           GPBInt32EnumDictionary *resultDict =
2537               GetOrCreateMapIvarWithField(self, field, syntax);
2538           [resultDict addRawEntriesFromDictionary:otherDict];
2539         } else {
2540           // The exact type doesn't matter, they all implement
2541           // -addEntriesFromDictionary:.
2542           GPBInt32Int32Dictionary *resultDict =
2543               GetOrCreateMapIvarWithField(self, field, syntax);
2544           [resultDict addEntriesFromDictionary:otherDict];
2545         }
2546       }
2547     }  // if (fieldType)..else if...else
2548   }  // for(fields)
2549
2550   // Unknown fields.
2551   if (!unknownFields_) {
2552     [self setUnknownFields:other.unknownFields];
2553   } else {
2554     [unknownFields_ mergeUnknownFields:other.unknownFields];
2555   }
2556
2557   // Extensions
2558
2559   if (other->extensionMap_.count == 0) {
2560     return;
2561   }
2562
2563   if (extensionMap_ == nil) {
2564     extensionMap_ =
2565         CloneExtensionMap(other->extensionMap_, NSZoneFromPointer(self));
2566   } else {
2567     for (GPBExtensionDescriptor *extension in other->extensionMap_) {
2568       id otherValue = [other->extensionMap_ objectForKey:extension];
2569       id value = [extensionMap_ objectForKey:extension];
2570       BOOL isMessageExtension = GPBExtensionIsMessage(extension);
2571
2572       if (extension.repeated) {
2573         NSMutableArray *list = value;
2574         if (list == nil) {
2575           list = [[NSMutableArray alloc] init];
2576           [extensionMap_ setObject:list forKey:extension];
2577           [list release];
2578         }
2579         if (isMessageExtension) {
2580           for (GPBMessage *otherListValue in otherValue) {
2581             GPBMessage *copiedValue = [otherListValue copy];
2582             [list addObject:copiedValue];
2583             [copiedValue release];
2584           }
2585         } else {
2586           [list addObjectsFromArray:otherValue];
2587         }
2588       } else {
2589         if (isMessageExtension) {
2590           if (value) {
2591             [(GPBMessage *)value mergeFrom:(GPBMessage *)otherValue];
2592           } else {
2593             GPBMessage *copiedValue = [otherValue copy];
2594             [extensionMap_ setObject:copiedValue forKey:extension];
2595             [copiedValue release];
2596           }
2597         } else {
2598           [extensionMap_ setObject:otherValue forKey:extension];
2599         }
2600       }
2601
2602       if (isMessageExtension && !extension.isRepeated) {
2603         GPBMessage *autocreatedValue =
2604             [[autocreatedExtensionMap_ objectForKey:extension] retain];
2605         // Must remove from the map before calling GPBClearMessageAutocreator()
2606         // so that GPBClearMessageAutocreator() knows its safe to clear.
2607         [autocreatedExtensionMap_ removeObjectForKey:extension];
2608         GPBClearMessageAutocreator(autocreatedValue);
2609         [autocreatedValue release];
2610       }
2611     }
2612   }
2613 }
2614
2615 #pragma mark - isEqual: & hash Support
2616
2617 - (BOOL)isEqual:(id)other {
2618   if (other == self) {
2619     return YES;
2620   }
2621   if (![other isKindOfClass:[GPBMessage class]]) {
2622     return NO;
2623   }
2624   GPBMessage *otherMsg = other;
2625   GPBDescriptor *descriptor = [[self class] descriptor];
2626   if ([[otherMsg class] descriptor] != descriptor) {
2627     return NO;
2628   }
2629   uint8_t *selfStorage = (uint8_t *)messageStorage_;
2630   uint8_t *otherStorage = (uint8_t *)otherMsg->messageStorage_;
2631
2632   for (GPBFieldDescriptor *field in descriptor->fields_) {
2633     if (GPBFieldIsMapOrArray(field)) {
2634       // In the case of a list or map, there is no _hasIvar to worry about.
2635       // NOTE: These are NSArray/GPB*Array or NSDictionary/GPB*Dictionary, but
2636       // the type doesn't really matter as the objects all support -count and
2637       // -isEqual:.
2638       NSArray *resultMapOrArray =
2639           GPBGetObjectIvarWithFieldNoAutocreate(self, field);
2640       NSArray *otherMapOrArray =
2641           GPBGetObjectIvarWithFieldNoAutocreate(other, field);
2642       // nil and empty are equal
2643       if (resultMapOrArray.count != 0 || otherMapOrArray.count != 0) {
2644         if (![resultMapOrArray isEqual:otherMapOrArray]) {
2645           return NO;
2646         }
2647       }
2648     } else {  // Single field
2649       int32_t hasIndex = GPBFieldHasIndex(field);
2650       uint32_t fieldNum = GPBFieldNumber(field);
2651       BOOL selfHas = GPBGetHasIvar(self, hasIndex, fieldNum);
2652       BOOL otherHas = GPBGetHasIvar(other, hasIndex, fieldNum);
2653       if (selfHas != otherHas) {
2654         return NO;  // Differing has values, not equal.
2655       }
2656       if (!selfHas) {
2657         // Same has values, was no, nothing else to check for this field.
2658         continue;
2659       }
2660       // Now compare the values.
2661       GPBDataType fieldDataType = GPBGetFieldDataType(field);
2662       size_t fieldOffset = field->description_->offset;
2663       switch (fieldDataType) {
2664         case GPBDataTypeBool: {
2665           // Bools are stored in has_bits to avoid needing explicit space in
2666           // the storage structure.
2667           // (the field number passed to the HasIvar helper doesn't really
2668           // matter since the offset is never negative)
2669           BOOL selfValue = GPBGetHasIvar(self, (int32_t)(fieldOffset), 0);
2670           BOOL otherValue = GPBGetHasIvar(other, (int32_t)(fieldOffset), 0);
2671           if (selfValue != otherValue) {
2672             return NO;
2673           }
2674           break;
2675         }
2676         case GPBDataTypeSFixed32:
2677         case GPBDataTypeInt32:
2678         case GPBDataTypeSInt32:
2679         case GPBDataTypeEnum:
2680         case GPBDataTypeFixed32:
2681         case GPBDataTypeUInt32:
2682         case GPBDataTypeFloat: {
2683           GPBInternalCompileAssert(sizeof(float) == sizeof(uint32_t), float_not_32_bits);
2684           // These are all 32bit, signed/unsigned doesn't matter for equality.
2685           uint32_t *selfValPtr = (uint32_t *)&selfStorage[fieldOffset];
2686           uint32_t *otherValPtr = (uint32_t *)&otherStorage[fieldOffset];
2687           if (*selfValPtr != *otherValPtr) {
2688             return NO;
2689           }
2690           break;
2691         }
2692         case GPBDataTypeSFixed64:
2693         case GPBDataTypeInt64:
2694         case GPBDataTypeSInt64:
2695         case GPBDataTypeFixed64:
2696         case GPBDataTypeUInt64:
2697         case GPBDataTypeDouble: {
2698           GPBInternalCompileAssert(sizeof(double) == sizeof(uint64_t), double_not_64_bits);
2699           // These are all 64bit, signed/unsigned doesn't matter for equality.
2700           uint64_t *selfValPtr = (uint64_t *)&selfStorage[fieldOffset];
2701           uint64_t *otherValPtr = (uint64_t *)&otherStorage[fieldOffset];
2702           if (*selfValPtr != *otherValPtr) {
2703             return NO;
2704           }
2705           break;
2706         }
2707         case GPBDataTypeBytes:
2708         case GPBDataTypeString:
2709         case GPBDataTypeMessage:
2710         case GPBDataTypeGroup: {
2711           // Type doesn't matter here, they all implement -isEqual:.
2712           id *selfValPtr = (id *)&selfStorage[fieldOffset];
2713           id *otherValPtr = (id *)&otherStorage[fieldOffset];
2714           if (![*selfValPtr isEqual:*otherValPtr]) {
2715             return NO;
2716           }
2717           break;
2718         }
2719       } // switch()
2720     }   // if(mapOrArray)...else
2721   }  // for(fields)
2722
2723   // nil and empty are equal
2724   if (extensionMap_.count != 0 || otherMsg->extensionMap_.count != 0) {
2725     if (![extensionMap_ isEqual:otherMsg->extensionMap_]) {
2726       return NO;
2727     }
2728   }
2729
2730   // nil and empty are equal
2731   GPBUnknownFieldSet *otherUnknowns = otherMsg->unknownFields_;
2732   if ([unknownFields_ countOfFields] != 0 ||
2733       [otherUnknowns countOfFields] != 0) {
2734     if (![unknownFields_ isEqual:otherUnknowns]) {
2735       return NO;
2736     }
2737   }
2738
2739   return YES;
2740 }
2741
2742 // It is very difficult to implement a generic hash for ProtoBuf messages that
2743 // will perform well. If you need hashing on your ProtoBufs (eg you are using
2744 // them as dictionary keys) you will probably want to implement a ProtoBuf
2745 // message specific hash as a category on your protobuf class. Do not make it a
2746 // category on GPBMessage as you will conflict with this hash, and will possibly
2747 // override hash for all generated protobufs. A good implementation of hash will
2748 // be really fast, so we would recommend only hashing protobufs that have an
2749 // identifier field of some kind that you can easily hash. If you implement
2750 // hash, we would strongly recommend overriding isEqual: in your category as
2751 // well, as the default implementation of isEqual: is extremely slow, and may
2752 // drastically affect performance in large sets.
2753 - (NSUInteger)hash {
2754   GPBDescriptor *descriptor = [[self class] descriptor];
2755   const NSUInteger prime = 19;
2756   uint8_t *storage = (uint8_t *)messageStorage_;
2757
2758   // Start with the descriptor and then mix it with some instance info.
2759   // Hopefully that will give a spread based on classes and what fields are set.
2760   NSUInteger result = (NSUInteger)descriptor;
2761
2762   for (GPBFieldDescriptor *field in descriptor->fields_) {
2763     if (GPBFieldIsMapOrArray(field)) {
2764       // Exact type doesn't matter, just check if there are any elements.
2765       NSArray *mapOrArray = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
2766       NSUInteger count = mapOrArray.count;
2767       if (count) {
2768         // NSArray/NSDictionary use count, use the field number and the count.
2769         result = prime * result + GPBFieldNumber(field);
2770         result = prime * result + count;
2771       }
2772     } else if (GPBGetHasIvarField(self, field)) {
2773       // Just using the field number seemed simple/fast, but then a small
2774       // message class where all the same fields are always set (to different
2775       // things would end up all with the same hash, so pull in some data).
2776       GPBDataType fieldDataType = GPBGetFieldDataType(field);
2777       size_t fieldOffset = field->description_->offset;
2778       switch (fieldDataType) {
2779         case GPBDataTypeBool: {
2780           // Bools are stored in has_bits to avoid needing explicit space in
2781           // the storage structure.
2782           // (the field number passed to the HasIvar helper doesn't really
2783           // matter since the offset is never negative)
2784           BOOL value = GPBGetHasIvar(self, (int32_t)(fieldOffset), 0);
2785           result = prime * result + value;
2786           break;
2787         }
2788         case GPBDataTypeSFixed32:
2789         case GPBDataTypeInt32:
2790         case GPBDataTypeSInt32:
2791         case GPBDataTypeEnum:
2792         case GPBDataTypeFixed32:
2793         case GPBDataTypeUInt32:
2794         case GPBDataTypeFloat: {
2795           GPBInternalCompileAssert(sizeof(float) == sizeof(uint32_t), float_not_32_bits);
2796           // These are all 32bit, just mix it in.
2797           uint32_t *valPtr = (uint32_t *)&storage[fieldOffset];
2798           result = prime * result + *valPtr;
2799           break;
2800         }
2801         case GPBDataTypeSFixed64:
2802         case GPBDataTypeInt64:
2803         case GPBDataTypeSInt64:
2804         case GPBDataTypeFixed64:
2805         case GPBDataTypeUInt64:
2806         case GPBDataTypeDouble: {
2807           GPBInternalCompileAssert(sizeof(double) == sizeof(uint64_t), double_not_64_bits);
2808           // These are all 64bit, just mix what fits into an NSUInteger in.
2809           uint64_t *valPtr = (uint64_t *)&storage[fieldOffset];
2810           result = prime * result + (NSUInteger)(*valPtr);
2811           break;
2812         }
2813         case GPBDataTypeBytes:
2814         case GPBDataTypeString: {
2815           // Type doesn't matter here, they both implement -hash:.
2816           id *valPtr = (id *)&storage[fieldOffset];
2817           result = prime * result + [*valPtr hash];
2818           break;
2819         }
2820
2821         case GPBDataTypeMessage:
2822         case GPBDataTypeGroup: {
2823           GPBMessage **valPtr = (GPBMessage **)&storage[fieldOffset];
2824           // Could call -hash on the sub message, but that could recurse pretty
2825           // deep; follow the lead of NSArray/NSDictionary and don't really
2826           // recurse for hash, instead use the field number and the descriptor
2827           // of the sub message.  Yes, this could suck for a bunch of messages
2828           // where they all only differ in the sub messages, but if you are
2829           // using a message with sub messages for something that needs -hash,
2830           // odds are you are also copying them as keys, and that deep copy
2831           // will also suck.
2832           result = prime * result + GPBFieldNumber(field);
2833           result = prime * result + (NSUInteger)[[*valPtr class] descriptor];
2834           break;
2835         }
2836       } // switch()
2837     }
2838   }
2839
2840   // Unknowns and extensions are not included.
2841
2842   return result;
2843 }
2844
2845 #pragma mark - Description Support
2846
2847 - (NSString *)description {
2848   NSString *textFormat = GPBTextFormatForMessage(self, @"    ");
2849   NSString *description = [NSString
2850       stringWithFormat:@"<%@ %p>: {\n%@}", [self class], self, textFormat];
2851   return description;
2852 }
2853
2854 #if defined(DEBUG) && DEBUG
2855
2856 // Xcode 5.1 added support for custom quick look info.
2857 // https://developer.apple.com/library/ios/documentation/IDEs/Conceptual/CustomClassDisplay_in_QuickLook/CH01-quick_look_for_custom_objects/CH01-quick_look_for_custom_objects.html#//apple_ref/doc/uid/TP40014001-CH2-SW1
2858 - (id)debugQuickLookObject {
2859   return GPBTextFormatForMessage(self, nil);
2860 }
2861
2862 #endif  // DEBUG
2863
2864 #pragma mark - SerializedSize
2865
2866 - (size_t)serializedSize {
2867   GPBDescriptor *descriptor = [[self class] descriptor];
2868   size_t result = 0;
2869
2870   // Has check is done explicitly, so GPBGetObjectIvarWithFieldNoAutocreate()
2871   // avoids doing the has check again.
2872
2873   // Fields.
2874   for (GPBFieldDescriptor *fieldDescriptor in descriptor->fields_) {
2875     GPBFieldType fieldType = fieldDescriptor.fieldType;
2876     GPBDataType fieldDataType = GPBGetFieldDataType(fieldDescriptor);
2877
2878     // Single Fields
2879     if (fieldType == GPBFieldTypeSingle) {
2880       BOOL selfHas = GPBGetHasIvarField(self, fieldDescriptor);
2881       if (!selfHas) {
2882         continue;  // Nothing to do.
2883       }
2884
2885       uint32_t fieldNumber = GPBFieldNumber(fieldDescriptor);
2886
2887       switch (fieldDataType) {
2888 #define CASE_SINGLE_POD(NAME, TYPE, FUNC_TYPE)                                \
2889         case GPBDataType##NAME: {                                             \
2890           TYPE fieldVal = GPBGetMessage##FUNC_TYPE##Field(self, fieldDescriptor); \
2891           result += GPBCompute##NAME##Size(fieldNumber, fieldVal);            \
2892           break;                                                              \
2893         }
2894 #define CASE_SINGLE_OBJECT(NAME)                                              \
2895         case GPBDataType##NAME: {                                             \
2896           id fieldVal = GPBGetObjectIvarWithFieldNoAutocreate(self, fieldDescriptor); \
2897           result += GPBCompute##NAME##Size(fieldNumber, fieldVal);            \
2898           break;                                                              \
2899         }
2900           CASE_SINGLE_POD(Bool, BOOL, Bool)
2901           CASE_SINGLE_POD(Fixed32, uint32_t, UInt32)
2902           CASE_SINGLE_POD(SFixed32, int32_t, Int32)
2903           CASE_SINGLE_POD(Float, float, Float)
2904           CASE_SINGLE_POD(Fixed64, uint64_t, UInt64)
2905           CASE_SINGLE_POD(SFixed64, int64_t, Int64)
2906           CASE_SINGLE_POD(Double, double, Double)
2907           CASE_SINGLE_POD(Int32, int32_t, Int32)
2908           CASE_SINGLE_POD(Int64, int64_t, Int64)
2909           CASE_SINGLE_POD(SInt32, int32_t, Int32)
2910           CASE_SINGLE_POD(SInt64, int64_t, Int64)
2911           CASE_SINGLE_POD(UInt32, uint32_t, UInt32)
2912           CASE_SINGLE_POD(UInt64, uint64_t, UInt64)
2913           CASE_SINGLE_OBJECT(Bytes)
2914           CASE_SINGLE_OBJECT(String)
2915           CASE_SINGLE_OBJECT(Message)
2916           CASE_SINGLE_OBJECT(Group)
2917           CASE_SINGLE_POD(Enum, int32_t, Int32)
2918 #undef CASE_SINGLE_POD
2919 #undef CASE_SINGLE_OBJECT
2920       }
2921
2922     // Repeated Fields
2923     } else if (fieldType == GPBFieldTypeRepeated) {
2924       id genericArray =
2925           GPBGetObjectIvarWithFieldNoAutocreate(self, fieldDescriptor);
2926       NSUInteger count = [genericArray count];
2927       if (count == 0) {
2928         continue;  // Nothing to add.
2929       }
2930       __block size_t dataSize = 0;
2931
2932       switch (fieldDataType) {
2933 #define CASE_REPEATED_POD(NAME, TYPE, ARRAY_TYPE)                             \
2934     CASE_REPEATED_POD_EXTRA(NAME, TYPE, ARRAY_TYPE, )
2935 #define CASE_REPEATED_POD_EXTRA(NAME, TYPE, ARRAY_TYPE, ARRAY_ACCESSOR_NAME)  \
2936         case GPBDataType##NAME: {                                             \
2937           GPB##ARRAY_TYPE##Array *array = genericArray;                       \
2938           [array enumerate##ARRAY_ACCESSOR_NAME##ValuesWithBlock:^(TYPE value, NSUInteger idx, BOOL *stop) { \
2939             _Pragma("unused(idx, stop)");                                     \
2940             dataSize += GPBCompute##NAME##SizeNoTag(value);                   \
2941           }];                                                                 \
2942           break;                                                              \
2943         }
2944 #define CASE_REPEATED_OBJECT(NAME)                                            \
2945         case GPBDataType##NAME: {                                             \
2946           for (id value in genericArray) {                                    \
2947             dataSize += GPBCompute##NAME##SizeNoTag(value);                   \
2948           }                                                                   \
2949           break;                                                              \
2950         }
2951           CASE_REPEATED_POD(Bool, BOOL, Bool)
2952           CASE_REPEATED_POD(Fixed32, uint32_t, UInt32)
2953           CASE_REPEATED_POD(SFixed32, int32_t, Int32)
2954           CASE_REPEATED_POD(Float, float, Float)
2955           CASE_REPEATED_POD(Fixed64, uint64_t, UInt64)
2956           CASE_REPEATED_POD(SFixed64, int64_t, Int64)
2957           CASE_REPEATED_POD(Double, double, Double)
2958           CASE_REPEATED_POD(Int32, int32_t, Int32)
2959           CASE_REPEATED_POD(Int64, int64_t, Int64)
2960           CASE_REPEATED_POD(SInt32, int32_t, Int32)
2961           CASE_REPEATED_POD(SInt64, int64_t, Int64)
2962           CASE_REPEATED_POD(UInt32, uint32_t, UInt32)
2963           CASE_REPEATED_POD(UInt64, uint64_t, UInt64)
2964           CASE_REPEATED_OBJECT(Bytes)
2965           CASE_REPEATED_OBJECT(String)
2966           CASE_REPEATED_OBJECT(Message)
2967           CASE_REPEATED_OBJECT(Group)
2968           CASE_REPEATED_POD_EXTRA(Enum, int32_t, Enum, Raw)
2969 #undef CASE_REPEATED_POD
2970 #undef CASE_REPEATED_POD_EXTRA
2971 #undef CASE_REPEATED_OBJECT
2972       }  // switch
2973       result += dataSize;
2974       size_t tagSize = GPBComputeTagSize(GPBFieldNumber(fieldDescriptor));
2975       if (fieldDataType == GPBDataTypeGroup) {
2976         // Groups have both a start and an end tag.
2977         tagSize *= 2;
2978       }
2979       if (fieldDescriptor.isPackable) {
2980         result += tagSize;
2981         result += GPBComputeSizeTSizeAsInt32NoTag(dataSize);
2982       } else {
2983         result += count * tagSize;
2984       }
2985
2986     // Map<> Fields
2987     } else {  // fieldType == GPBFieldTypeMap
2988       if (GPBDataTypeIsObject(fieldDataType) &&
2989           (fieldDescriptor.mapKeyDataType == GPBDataTypeString)) {
2990         // If key type was string, then the map is an NSDictionary.
2991         NSDictionary *map =
2992             GPBGetObjectIvarWithFieldNoAutocreate(self, fieldDescriptor);
2993         if (map) {
2994           result += GPBDictionaryComputeSizeInternalHelper(map, fieldDescriptor);
2995         }
2996       } else {
2997         // Type will be GPB*GroupDictionary, exact type doesn't matter.
2998         GPBInt32Int32Dictionary *map =
2999             GPBGetObjectIvarWithFieldNoAutocreate(self, fieldDescriptor);
3000         result += [map computeSerializedSizeAsField:fieldDescriptor];
3001       }
3002     }
3003   }  // for(fields)
3004
3005   // Add any unknown fields.
3006   if (descriptor.wireFormat) {
3007     result += [unknownFields_ serializedSizeAsMessageSet];
3008   } else {
3009     result += [unknownFields_ serializedSize];
3010   }
3011
3012   // Add any extensions.
3013   for (GPBExtensionDescriptor *extension in extensionMap_) {
3014     id value = [extensionMap_ objectForKey:extension];
3015     result += GPBComputeExtensionSerializedSizeIncludingTag(extension, value);
3016   }
3017
3018   return result;
3019 }
3020
3021 #pragma mark - Resolve Methods Support
3022
3023 typedef struct ResolveIvarAccessorMethodResult {
3024   IMP impToAdd;
3025   SEL encodingSelector;
3026 } ResolveIvarAccessorMethodResult;
3027
3028 // |field| can be __unsafe_unretained because they are created at startup
3029 // and are essentially global. No need to pay for retain/release when
3030 // they are captured in blocks.
3031 static void ResolveIvarGet(__unsafe_unretained GPBFieldDescriptor *field,
3032                            ResolveIvarAccessorMethodResult *result) {
3033   GPBDataType fieldDataType = GPBGetFieldDataType(field);
3034   switch (fieldDataType) {
3035 #define CASE_GET(NAME, TYPE, TRUE_NAME)                          \
3036     case GPBDataType##NAME: {                                    \
3037       result->impToAdd = imp_implementationWithBlock(^(id obj) { \
3038         return GPBGetMessage##TRUE_NAME##Field(obj, field);      \
3039        });                                                       \
3040       result->encodingSelector = @selector(get##NAME);           \
3041       break;                                                     \
3042     }
3043 #define CASE_GET_OBJECT(NAME, TYPE, TRUE_NAME)                   \
3044     case GPBDataType##NAME: {                                    \
3045       result->impToAdd = imp_implementationWithBlock(^(id obj) { \
3046         return GPBGetObjectIvarWithField(obj, field);            \
3047        });                                                       \
3048       result->encodingSelector = @selector(get##NAME);           \
3049       break;                                                     \
3050     }
3051       CASE_GET(Bool, BOOL, Bool)
3052       CASE_GET(Fixed32, uint32_t, UInt32)
3053       CASE_GET(SFixed32, int32_t, Int32)
3054       CASE_GET(Float, float, Float)
3055       CASE_GET(Fixed64, uint64_t, UInt64)
3056       CASE_GET(SFixed64, int64_t, Int64)
3057       CASE_GET(Double, double, Double)
3058       CASE_GET(Int32, int32_t, Int32)
3059       CASE_GET(Int64, int64_t, Int64)
3060       CASE_GET(SInt32, int32_t, Int32)
3061       CASE_GET(SInt64, int64_t, Int64)
3062       CASE_GET(UInt32, uint32_t, UInt32)
3063       CASE_GET(UInt64, uint64_t, UInt64)
3064       CASE_GET_OBJECT(Bytes, id, Object)
3065       CASE_GET_OBJECT(String, id, Object)
3066       CASE_GET_OBJECT(Message, id, Object)
3067       CASE_GET_OBJECT(Group, id, Object)
3068       CASE_GET(Enum, int32_t, Enum)
3069 #undef CASE_GET
3070   }
3071 }
3072
3073 // See comment about __unsafe_unretained on ResolveIvarGet.
3074 static void ResolveIvarSet(__unsafe_unretained GPBFieldDescriptor *field,
3075                            GPBFileSyntax syntax,
3076                            ResolveIvarAccessorMethodResult *result) {
3077   GPBDataType fieldDataType = GPBGetFieldDataType(field);
3078   switch (fieldDataType) {
3079 #define CASE_SET(NAME, TYPE, TRUE_NAME)                                       \
3080     case GPBDataType##NAME: {                                                 \
3081       result->impToAdd = imp_implementationWithBlock(^(id obj, TYPE value) {  \
3082         return GPBSet##TRUE_NAME##IvarWithFieldInternal(obj, field, value, syntax); \
3083       });                                                                     \
3084       result->encodingSelector = @selector(set##NAME:);                       \
3085       break;                                                                  \
3086     }
3087       CASE_SET(Bool, BOOL, Bool)
3088       CASE_SET(Fixed32, uint32_t, UInt32)
3089       CASE_SET(SFixed32, int32_t, Int32)
3090       CASE_SET(Float, float, Float)
3091       CASE_SET(Fixed64, uint64_t, UInt64)
3092       CASE_SET(SFixed64, int64_t, Int64)
3093       CASE_SET(Double, double, Double)
3094       CASE_SET(Int32, int32_t, Int32)
3095       CASE_SET(Int64, int64_t, Int64)
3096       CASE_SET(SInt32, int32_t, Int32)
3097       CASE_SET(SInt64, int64_t, Int64)
3098       CASE_SET(UInt32, uint32_t, UInt32)
3099       CASE_SET(UInt64, uint64_t, UInt64)
3100       CASE_SET(Bytes, id, Object)
3101       CASE_SET(String, id, Object)
3102       CASE_SET(Message, id, Object)
3103       CASE_SET(Group, id, Object)
3104       CASE_SET(Enum, int32_t, Enum)
3105 #undef CASE_SET
3106   }
3107 }
3108
3109 + (BOOL)resolveInstanceMethod:(SEL)sel {
3110   const GPBDescriptor *descriptor = [self descriptor];
3111   if (!descriptor) {
3112     return [super resolveInstanceMethod:sel];
3113   }
3114
3115   // NOTE: hasOrCountSel_/setHasSel_ will be NULL if the field for the given
3116   // message should not have has support (done in GPBDescriptor.m), so there is
3117   // no need for checks here to see if has*/setHas* are allowed.
3118   ResolveIvarAccessorMethodResult result = {NULL, NULL};
3119
3120   // See comment about __unsafe_unretained on ResolveIvarGet.
3121   for (__unsafe_unretained GPBFieldDescriptor *field in descriptor->fields_) {
3122     BOOL isMapOrArray = GPBFieldIsMapOrArray(field);
3123     if (!isMapOrArray) {
3124       // Single fields.
3125       if (sel == field->getSel_) {
3126         ResolveIvarGet(field, &result);
3127         break;
3128       } else if (sel == field->setSel_) {
3129         ResolveIvarSet(field, descriptor.file.syntax, &result);
3130         break;
3131       } else if (sel == field->hasOrCountSel_) {
3132         int32_t index = GPBFieldHasIndex(field);
3133         uint32_t fieldNum = GPBFieldNumber(field);
3134         result.impToAdd = imp_implementationWithBlock(^(id obj) {
3135           return GPBGetHasIvar(obj, index, fieldNum);
3136         });
3137         result.encodingSelector = @selector(getBool);
3138         break;
3139       } else if (sel == field->setHasSel_) {
3140         result.impToAdd = imp_implementationWithBlock(^(id obj, BOOL value) {
3141           if (value) {
3142             [NSException raise:NSInvalidArgumentException
3143                         format:@"%@: %@ can only be set to NO (to clear field).",
3144                                [obj class],
3145                                NSStringFromSelector(field->setHasSel_)];
3146           }
3147           GPBClearMessageField(obj, field);
3148         });
3149         result.encodingSelector = @selector(setBool:);
3150         break;
3151       } else {
3152         GPBOneofDescriptor *oneof = field->containingOneof_;
3153         if (oneof && (sel == oneof->caseSel_)) {
3154           int32_t index = GPBFieldHasIndex(field);
3155           result.impToAdd = imp_implementationWithBlock(^(id obj) {
3156             return GPBGetHasOneof(obj, index);
3157           });
3158           result.encodingSelector = @selector(getEnum);
3159           break;
3160         }
3161       }
3162     } else {
3163       // map<>/repeated fields.
3164       if (sel == field->getSel_) {
3165         if (field.fieldType == GPBFieldTypeRepeated) {
3166           result.impToAdd = imp_implementationWithBlock(^(id obj) {
3167             return GetArrayIvarWithField(obj, field);
3168           });
3169         } else {
3170           result.impToAdd = imp_implementationWithBlock(^(id obj) {
3171             return GetMapIvarWithField(obj, field);
3172           });
3173         }
3174         result.encodingSelector = @selector(getArray);
3175         break;
3176       } else if (sel == field->setSel_) {
3177         // Local for syntax so the block can directly capture it and not the
3178         // full lookup.
3179         const GPBFileSyntax syntax = descriptor.file.syntax;
3180         result.impToAdd = imp_implementationWithBlock(^(id obj, id value) {
3181           return GPBSetObjectIvarWithFieldInternal(obj, field, value, syntax);
3182         });
3183         result.encodingSelector = @selector(setArray:);
3184         break;
3185       } else if (sel == field->hasOrCountSel_) {
3186         result.impToAdd = imp_implementationWithBlock(^(id obj) {
3187           // Type doesn't matter, all *Array and *Dictionary types support
3188           // -count.
3189           NSArray *arrayOrMap =
3190               GPBGetObjectIvarWithFieldNoAutocreate(obj, field);
3191           return [arrayOrMap count];
3192         });
3193         result.encodingSelector = @selector(getArrayCount);
3194         break;
3195       }
3196     }
3197   }
3198   if (result.impToAdd) {
3199     const char *encoding =
3200         GPBMessageEncodingForSelector(result.encodingSelector, YES);
3201     Class msgClass = descriptor.messageClass;
3202     BOOL methodAdded = class_addMethod(msgClass, sel, result.impToAdd, encoding);
3203     // class_addMethod() is documented as also failing if the method was already
3204     // added; so we check if the method is already there and return success so
3205     // the method dispatch will still happen.  Why would it already be added?
3206     // Two threads could cause the same method to be bound at the same time,
3207     // but only one will actually bind it; the other still needs to return true
3208     // so things will dispatch.
3209     if (!methodAdded) {
3210       methodAdded = GPBClassHasSel(msgClass, sel);
3211     }
3212     return methodAdded;
3213   }
3214   return [super resolveInstanceMethod:sel];
3215 }
3216
3217 + (BOOL)resolveClassMethod:(SEL)sel {
3218   // Extensions scoped to a Message and looked up via class methods.
3219   if (GPBResolveExtensionClassMethod([self descriptor].messageClass, sel)) {
3220     return YES;
3221   }
3222   return [super resolveClassMethod:sel];
3223 }
3224
3225 #pragma mark - NSCoding Support
3226
3227 + (BOOL)supportsSecureCoding {
3228   return YES;
3229 }
3230
3231 - (instancetype)initWithCoder:(NSCoder *)aDecoder {
3232   self = [self init];
3233   if (self) {
3234     NSData *data =
3235         [aDecoder decodeObjectOfClass:[NSData class] forKey:kGPBDataCoderKey];
3236     if (data.length) {
3237       [self mergeFromData:data extensionRegistry:nil];
3238     }
3239   }
3240   return self;
3241 }
3242
3243 - (void)encodeWithCoder:(NSCoder *)aCoder {
3244   NSData *data = [self data];
3245   if (data.length) {
3246     [aCoder encodeObject:data forKey:kGPBDataCoderKey];
3247   }
3248 }
3249
3250 #pragma mark - KVC Support
3251
3252 + (BOOL)accessInstanceVariablesDirectly {
3253   // Make sure KVC doesn't use instance variables.
3254   return NO;
3255 }
3256
3257 @end
3258
3259 #pragma mark - Messages from GPBUtilities.h but defined here for access to helpers.
3260
3261 // Only exists for public api, no core code should use this.
3262 id GPBGetMessageRepeatedField(GPBMessage *self, GPBFieldDescriptor *field) {
3263 #if defined(DEBUG) && DEBUG
3264   if (field.fieldType != GPBFieldTypeRepeated) {
3265     [NSException raise:NSInvalidArgumentException
3266                 format:@"%@.%@ is not a repeated field.",
3267      [self class], field.name];
3268   }
3269 #endif
3270   GPBDescriptor *descriptor = [[self class] descriptor];
3271   GPBFileSyntax syntax = descriptor.file.syntax;
3272   return GetOrCreateArrayIvarWithField(self, field, syntax);
3273 }
3274
3275 // Only exists for public api, no core code should use this.
3276 id GPBGetMessageMapField(GPBMessage *self, GPBFieldDescriptor *field) {
3277 #if defined(DEBUG) && DEBUG
3278   if (field.fieldType != GPBFieldTypeMap) {
3279     [NSException raise:NSInvalidArgumentException
3280                 format:@"%@.%@ is not a map<> field.",
3281      [self class], field.name];
3282   }
3283 #endif
3284   GPBDescriptor *descriptor = [[self class] descriptor];
3285   GPBFileSyntax syntax = descriptor.file.syntax;
3286   return GetOrCreateMapIvarWithField(self, field, syntax);
3287 }
3288
3289 id GPBGetObjectIvarWithField(GPBMessage *self, GPBFieldDescriptor *field) {
3290   NSCAssert(!GPBFieldIsMapOrArray(field), @"Shouldn't get here");
3291   if (GPBGetHasIvarField(self, field)) {
3292     uint8_t *storage = (uint8_t *)self->messageStorage_;
3293     id *typePtr = (id *)&storage[field->description_->offset];
3294     return *typePtr;
3295   }
3296   // Not set...
3297
3298   // Non messages (string/data), get their default.
3299   if (!GPBFieldDataTypeIsMessage(field)) {
3300     return field.defaultValue.valueMessage;
3301   }
3302
3303   GPBPrepareReadOnlySemaphore(self);
3304   dispatch_semaphore_wait(self->readOnlySemaphore_, DISPATCH_TIME_FOREVER);
3305   GPBMessage *result = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
3306   if (!result) {
3307     // For non repeated messages, create the object, set it and return it.
3308     // This object will not initially be visible via GPBGetHasIvar, so
3309     // we save its creator so it can become visible if it's mutated later.
3310     result = GPBCreateMessageWithAutocreator(field.msgClass, self, field);
3311     GPBSetAutocreatedRetainedObjectIvarWithField(self, field, result);
3312   }
3313   dispatch_semaphore_signal(self->readOnlySemaphore_);
3314   return result;
3315 }
3316
3317 #pragma clang diagnostic pop