third_party/protobuf: Update to HEAD (f52e188fe4)

third_party/protobuf/objectivec/GPBMessage.m

 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
 // https://developers.google.com/protocol-buffers/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
@@ skipping 26 matching lines @@
 #import "GPBCodedInputStream_PackagePrivate.h"
 #import "GPBCodedOutputStream_PackagePrivate.h"
 #import "GPBDescriptor_PackagePrivate.h"
 #import "GPBDictionary_PackagePrivate.h"
 #import "GPBExtensionInternals.h"
 #import "GPBExtensionRegistry.h"
 #import "GPBRootObject_PackagePrivate.h"
 #import "GPBUnknownFieldSet_PackagePrivate.h"
 #import "GPBUtilities_PackagePrivate.h"
 
+// Direct access is use for speed, to avoid even internally declaring things
+// read/write, etc. The warning is enabled in the project to ensure code calling
+// protos can turn on -Wdirect-ivar-access without issues.
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdirect-ivar-access"
+
 NSString *const GPBMessageErrorDomain =
     GPBNSStringifySymbol(GPBMessageErrorDomain);
 
-#ifdef DEBUG
-NSString *const GPBExceptionMessageKey =
-    GPBNSStringifySymbol(GPBExceptionMessage);
-#endif  // DEBUG
+NSString *const GPBErrorReasonKey = @"Reason";
 
 static NSString *const kGPBDataCoderKey = @"GPBData";
 
 //
 // PLEASE REMEMBER:
 //
 // This is the base class for *all* messages generated, so any selector defined,
 // *public* or *private* could end up colliding with a proto message field. So
 // avoid using selectors that could match a property, use C functions to hide
 // them, etc.
@@ skipping 24 matching lines @@
                             GPBMessage *autocreator)
     __attribute__((ns_returns_retained));
 static id GetOrCreateMapIvarWithField(GPBMessage *self,
                                       GPBFieldDescriptor *field,
                                       GPBFileSyntax syntax);
 static id GetMapIvarWithField(GPBMessage *self, GPBFieldDescriptor *field);
 static NSMutableDictionary *CloneExtensionMap(NSDictionary *extensionMap,
                                               NSZone *zone)
     __attribute__((ns_returns_retained));
 
+#ifdef DEBUG
 static NSError *MessageError(NSInteger code, NSDictionary *userInfo) {
   return [NSError errorWithDomain:GPBMessageErrorDomain
                              code:code
                          userInfo:userInfo];
 }
+#endif
 
-static NSError *MessageErrorWithReason(NSInteger code, NSString *reason) {
-  NSDictionary *userInfo = nil;
-  if ([reason length]) {
-    userInfo = @{ @"Reason" : reason };
+static NSError *ErrorFromException(NSException *exception) {
+  NSError *error = nil;
+
+  if ([exception.name isEqual:GPBCodedInputStreamException]) {
+    NSDictionary *exceptionInfo = exception.userInfo;
+    error = exceptionInfo[GPBCodedInputStreamUnderlyingErrorKey];
   }
-  return MessageError(code, userInfo);
+
+  if (!error) {
+    NSString *reason = exception.reason;
+    NSDictionary *userInfo = nil;
+    if ([reason length]) {
+      userInfo = @{ GPBErrorReasonKey : reason };
+    }
+
+    error = [NSError errorWithDomain:GPBMessageErrorDomain
+                                code:GPBMessageErrorCodeOther
+                            userInfo:userInfo];
+  }
+  return error;
 }
 
-
 static void CheckExtension(GPBMessage *self,
                            GPBExtensionDescriptor *extension) {
   if ([self class] != extension.containingMessageClass) {
     [NSException
          raise:NSInvalidArgumentException
         format:@"Extension %@ used on wrong class (%@ instead of %@)",
                extension.singletonName,
                [self class], extension.containingMessageClass];
   }
 }
@@ skipping 564 matching lines @@
     }
   }
   NSCAssert(NO, @"Unknown autocreated %@ for %@.", [dictionary class], self);
 }
 
 void GPBClearMessageAutocreator(GPBMessage *self) {
   if ((self == nil) || !self->autocreator_) {
     return;
   }
 
-#if DEBUG && !defined(NS_BLOCK_ASSERTIONS)
+#if defined(DEBUG) && DEBUG && !defined(NS_BLOCK_ASSERTIONS)
   // Either the autocreator must have its "has" flag set to YES, or it must be
   // NO and not equal to ourselves.
   BOOL autocreatorHas =
       (self->autocreatorField_
            ? GPBGetHasIvarField(self->autocreator_, self->autocreatorField_)
            : [self->autocreator_ hasExtension:self->autocreatorExtension_]);
   GPBMessage *autocreatorFieldValue =
       (self->autocreatorField_
            ? GPBGetObjectIvarWithFieldNoAutocreate(self->autocreator_,
                                                    self->autocreatorField_)
@@ skipping 101 matching lines @@
     @try {
       [self mergeFromData:data extensionRegistry:extensionRegistry];
       if (errorPtr) {
         *errorPtr = nil;
       }
     }
     @catch (NSException *exception) {
       [self release];
       self = nil;
       if (errorPtr) {
-        *errorPtr = MessageErrorWithReason(GPBMessageErrorCodeMalformedData,
-                                           exception.reason);
+        *errorPtr = ErrorFromException(exception);
       }
     }
 #ifdef DEBUG
     if (self && !self.initialized) {
       [self release];
       self = nil;
       if (errorPtr) {
         *errorPtr = MessageError(GPBMessageErrorCodeMissingRequiredField, nil);
       }
     }
@@ skipping 10 matching lines @@
     @try {
       [self mergeFromCodedInputStream:input extensionRegistry:extensionRegistry];
       if (errorPtr) {
         *errorPtr = nil;
       }
     }
     @catch (NSException *exception) {
       [self release];
       self = nil;
       if (errorPtr) {
-        *errorPtr = MessageErrorWithReason(GPBMessageErrorCodeMalformedData,
-                                           exception.reason);
+        *errorPtr = ErrorFromException(exception);
       }
     }
 #ifdef DEBUG
     if (self && !self.initialized) {
       [self release];
       self = nil;
       if (errorPtr) {
         *errorPtr = MessageError(GPBMessageErrorCodeMissingRequiredField, nil);
       }
     }
@@ skipping 866 matching lines @@
   dispatch_semaphore_signal(readOnlySemaphore_);
   return value;
 }
 
 - (id)getExistingExtension:(GPBExtensionDescriptor *)extension {
   // This is an internal method so we don't need to call CheckExtension().
   return [extensionMap_ objectForKey:extension];
 }
 
 - (BOOL)hasExtension:(GPBExtensionDescriptor *)extension {
-#if DEBUG
+#if defined(DEBUG) && DEBUG
   CheckExtension(self, extension);
 #endif  // DEBUG
   return nil != [extensionMap_ objectForKey:extension];
 }
 
 - (NSArray *)extensionsCurrentlySet {
   return [extensionMap_ allKeys];
 }
 
 - (void)writeExtensionsToCodedOutputStream:(GPBCodedOutputStream *)output
                                      range:(GPBExtensionRange)range {
   NSArray *sortedExtensions = [[extensionMap_ allKeys]
       sortedArrayUsingSelector:@selector(compareByFieldNumber:)];
   uint32_t start = range.start;
   uint32_t end = range.end;
   for (GPBExtensionDescriptor *extension in sortedExtensions) {
     uint32_t fieldNumber = extension.fieldNumber;
     if (fieldNumber >= start && fieldNumber < end) {
       id value = [extensionMap_ objectForKey:extension];
       GPBWriteExtensionValueToOutputStream(extension, value, output);
     }
   }
 }
 
-- (NSArray *)sortedExtensionsInUse {
-  return [[extensionMap_ allKeys]
-      sortedArrayUsingSelector:@selector(compareByFieldNumber:)];
-}
-
 - (void)setExtension:(GPBExtensionDescriptor *)extension value:(id)value {
   if (!value) {
     [self clearExtension:extension];
     return;
   }
 
   CheckExtension(self, extension);
 
   if (extension.repeated) {
     [NSException raise:NSInvalidArgumentException
@@ skipping 136 matching lines @@
   @try {
     [message mergeDelimitedFromCodedInputStream:input
                               extensionRegistry:extensionRegistry];
     if (errorPtr) {
       *errorPtr = nil;
     }
   }
   @catch (NSException *exception) {
     message = nil;
     if (errorPtr) {
-      *errorPtr = MessageErrorWithReason(GPBMessageErrorCodeMalformedData,
-                                         exception.reason);
+      *errorPtr = ErrorFromException(exception);
     }
   }
 #ifdef DEBUG
   if (message && !message.initialized) {
     message = nil;
     if (errorPtr) {
       *errorPtr = MessageError(GPBMessageErrorCodeMissingRequiredField, nil);
     }
   }
 #endif
@@ skipping 320 matching lines @@
   GPBDescriptor *descriptor = [self descriptor];
   GPBFileSyntax syntax = descriptor.file.syntax;
   GPBCodedInputStreamState *state = &input->state_;
   uint32_t tag = 0;
   NSUInteger startingIndex = 0;
   NSArray *fields = descriptor->fields_;
   NSUInteger numFields = fields.count;
   while (YES) {
     BOOL merged = NO;
     tag = GPBCodedInputStreamReadTag(state);
+    if (tag == 0) {
+      break;  // Reached end.
+    }
     for (NSUInteger i = 0; i < numFields; ++i) {
       if (startingIndex >= numFields) startingIndex = 0;
       GPBFieldDescriptor *fieldDescriptor = fields[startingIndex];
       if (GPBFieldTag(fieldDescriptor) == tag) {
         GPBFieldType fieldType = fieldDescriptor.fieldType;
         if (fieldType == GPBFieldTypeSingle) {
           MergeSingleFieldFromCodedInputStream(self, fieldDescriptor, syntax,
                                                input, extensionRegistry);
           // Well formed protos will only have a single field once, advance
           // the starting index to the next field.
@@ skipping 18 matching lines @@
                         field:fieldDescriptor
                 parentMessage:self];
         }
         merged = YES;
         break;
       } else {
         startingIndex += 1;
       }
     }  // for(i < numFields)
 
-    if (!merged) {
+    if (!merged && (tag != 0)) {
       // Primitive, repeated types can be packed on unpacked on the wire, and
       // are parsed either way.  The above loop covered tag in the preferred
       // for, so this need to check the alternate form.
       for (NSUInteger i = 0; i < numFields; ++i) {
         if (startingIndex >= numFields) startingIndex = 0;
         GPBFieldDescriptor *fieldDescriptor = fields[startingIndex];
         if ((fieldDescriptor.fieldType == GPBFieldTypeRepeated) &&
             !GPBFieldDataTypeIsObject(fieldDescriptor) &&
             (GPBFieldAlternateTag(fieldDescriptor) == tag)) {
           BOOL alternateIsPacked = !fieldDescriptor.isPackable;
@@ skipping 234 matching lines @@
         [autocreatedExtensionMap_ removeObjectForKey:extension];
         GPBClearMessageAutocreator(autocreatedValue);
         [autocreatedValue release];
       }
     }
   }
 }
 
 #pragma mark - isEqual: & hash Support
 
-- (BOOL)isEqual:(GPBMessage *)other {
+- (BOOL)isEqual:(id)other {
   if (other == self) {
     return YES;
   }
   if (![other isKindOfClass:[self class]] &&
       ![self isKindOfClass:[other class]]) {
     return NO;
   }
 
+  GPBMessage *otherMsg = other;
   GPBDescriptor *descriptor = [[self class] descriptor];
   uint8_t *selfStorage = (uint8_t *)messageStorage_;
-  uint8_t *otherStorage = (uint8_t *)other->messageStorage_;
+  uint8_t *otherStorage = (uint8_t *)otherMsg->messageStorage_;
 
   for (GPBFieldDescriptor *field in descriptor->fields_) {
     if (GPBFieldIsMapOrArray(field)) {
       // In the case of a list or map, there is no _hasIvar to worry about.
       // NOTE: These are NSArray/GPB*Array or NSDictionary/GPB*Dictionary, but
       // the type doesn't really matter as the objects all support -count and
       // -isEqual:.
       NSArray *resultMapOrArray =
           GPBGetObjectIvarWithFieldNoAutocreate(self, field);
       NSArray *otherMapOrArray =
@@ skipping 32 matching lines @@
           }
           break;
         }
         case GPBDataTypeSFixed32:
         case GPBDataTypeInt32:
         case GPBDataTypeSInt32:
         case GPBDataTypeEnum:
         case GPBDataTypeFixed32:
         case GPBDataTypeUInt32:
         case GPBDataTypeFloat: {
-          _GPBCompileAssert(sizeof(float) == sizeof(uint32_t), float_not_32_bits);
+          GPBInternalCompileAssert(sizeof(float) == sizeof(uint32_t), float_not_32_bits);
           // These are all 32bit, signed/unsigned doesn't matter for equality.
           uint32_t *selfValPtr = (uint32_t *)&selfStorage[fieldOffset];
           uint32_t *otherValPtr = (uint32_t *)&otherStorage[fieldOffset];
           if (*selfValPtr != *otherValPtr) {
             return NO;
           }
           break;
         }
         case GPBDataTypeSFixed64:
         case GPBDataTypeInt64:
         case GPBDataTypeSInt64:
         case GPBDataTypeFixed64:
         case GPBDataTypeUInt64:
         case GPBDataTypeDouble: {
-          _GPBCompileAssert(sizeof(double) == sizeof(uint64_t), double_not_64_bits);
+          GPBInternalCompileAssert(sizeof(double) == sizeof(uint64_t), double_not_64_bits);
           // These are all 64bit, signed/unsigned doesn't matter for equality.
           uint64_t *selfValPtr = (uint64_t *)&selfStorage[fieldOffset];
           uint64_t *otherValPtr = (uint64_t *)&otherStorage[fieldOffset];
           if (*selfValPtr != *otherValPtr) {
             return NO;
           }
           break;
         }
         case GPBDataTypeBytes:
         case GPBDataTypeString:
         case GPBDataTypeMessage:
         case GPBDataTypeGroup: {
           // Type doesn't matter here, they all implement -isEqual:.
           id *selfValPtr = (id *)&selfStorage[fieldOffset];
           id *otherValPtr = (id *)&otherStorage[fieldOffset];
           if (![*selfValPtr isEqual:*otherValPtr]) {
             return NO;
           }
           break;
         }
       } // switch()
     }   // if(mapOrArray)...else
   }  // for(fields)
 
   // nil and empty are equal
-  if (extensionMap_.count != 0 || other->extensionMap_.count != 0) {
-    if (![extensionMap_ isEqual:other->extensionMap_]) {
+  if (extensionMap_.count != 0 || otherMsg->extensionMap_.count != 0) {
+    if (![extensionMap_ isEqual:otherMsg->extensionMap_]) {
       return NO;
     }
   }
 
   // nil and empty are equal
-  GPBUnknownFieldSet *otherUnknowns = other->unknownFields_;
+  GPBUnknownFieldSet *otherUnknowns = otherMsg->unknownFields_;
   if ([unknownFields_ countOfFields] != 0 ||
       [otherUnknowns countOfFields] != 0) {
     if (![unknownFields_ isEqual:otherUnknowns]) {
       return NO;
     }
   }
 
   return YES;
 }
 
@@ skipping 43 matching lines @@
           result = prime * result + value;
           break;
         }
         case GPBDataTypeSFixed32:
         case GPBDataTypeInt32:
         case GPBDataTypeSInt32:
         case GPBDataTypeEnum:
         case GPBDataTypeFixed32:
         case GPBDataTypeUInt32:
         case GPBDataTypeFloat: {
-          _GPBCompileAssert(sizeof(float) == sizeof(uint32_t), float_not_32_bits);
+          GPBInternalCompileAssert(sizeof(float) == sizeof(uint32_t), float_not_32_bits);
           // These are all 32bit, just mix it in.
           uint32_t *valPtr = (uint32_t *)&storage[fieldOffset];
           result = prime * result + *valPtr;
           break;
         }
         case GPBDataTypeSFixed64:
         case GPBDataTypeInt64:
         case GPBDataTypeSInt64:
         case GPBDataTypeFixed64:
         case GPBDataTypeUInt64:
         case GPBDataTypeDouble: {
-          _GPBCompileAssert(sizeof(double) == sizeof(uint64_t), double_not_64_bits);
+          GPBInternalCompileAssert(sizeof(double) == sizeof(uint64_t), double_not_64_bits);
           // These are all 64bit, just mix what fits into an NSUInteger in.
           uint64_t *valPtr = (uint64_t *)&storage[fieldOffset];
           result = prime * result + (NSUInteger)(*valPtr);
           break;
         }
         case GPBDataTypeBytes:
         case GPBDataTypeString: {
           // Type doesn't matter here, they both implement -hash:.
           id *valPtr = (id *)&storage[fieldOffset];
           result = prime * result + [*valPtr hash];
@@ skipping 26 matching lines @@
 
 #pragma mark - Description Support
 
 - (NSString *)description {
   NSString *textFormat = GPBTextFormatForMessage(self, @"    ");
   NSString *description = [NSString
       stringWithFormat:@"<%@ %p>: {\n%@}", [self class], self, textFormat];
   return description;
 }
 
-#if DEBUG
+#if defined(DEBUG) && DEBUG
 
 // Xcode 5.1 added support for custom quick look info.
 // 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
 - (id)debugQuickLookObject {
   return GPBTextFormatForMessage(self, nil);
 }
 
 #endif  // DEBUG
 
 #pragma mark - SerializedSize
@@ skipping 369 matching lines @@
 }
 
 #pragma mark - KVC Support
 
 + (BOOL)accessInstanceVariablesDirectly {
   // Make sure KVC doesn't use instance variables.
   return NO;
 }
 
 @end
+
+#pragma mark - Messages from GPBUtilities.h but defined here for access to helpers.
+
+// Only exists for public api, no core code should use this.
+id GPBGetMessageRepeatedField(GPBMessage *self, GPBFieldDescriptor *field) {
+#if defined(DEBUG) && DEBUG
+  if (field.fieldType != GPBFieldTypeRepeated) {
+    [NSException raise:NSInvalidArgumentException
+                format:@"%@.%@ is not a repeated field.",
+     [self class], field.name];
+  }
+#endif
+  GPBDescriptor *descriptor = [[self class] descriptor];
+  GPBFileSyntax syntax = descriptor.file.syntax;
+  return GetOrCreateArrayIvarWithField(self, field, syntax);
+}
+
+// Only exists for public api, no core code should use this.
+id GPBGetMessageMapField(GPBMessage *self, GPBFieldDescriptor *field) {
+#if defined(DEBUG) && DEBUG
+  if (field.fieldType != GPBFieldTypeMap) {
+    [NSException raise:NSInvalidArgumentException
+                format:@"%@.%@ is not a map<> field.",
+     [self class], field.name];
+  }
+#endif
+  GPBDescriptor *descriptor = [[self class] descriptor];
+  GPBFileSyntax syntax = descriptor.file.syntax;
+  return GetOrCreateMapIvarWithField(self, field, syntax);
+}
+
+#pragma clang diagnostic pop