Update third_party/protobuf to protobuf-v3.0.0-beta-3

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 17 matching lines @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #import "GPBMessage_PackagePrivate.h"
 
 #import <objc/runtime.h>
 #import <objc/message.h>
 
 #import "GPBArray_PackagePrivate.h"
 #import "GPBCodedInputStream_PackagePrivate.h"
-#import "GPBCodedOutputStream.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"
 
 NSString *const GPBMessageErrorDomain =
     GPBNSStringifySymbol(GPBMessageErrorDomain);
 
 #ifdef DEBUG
 NSString *const GPBExceptionMessageKey =
     GPBNSStringifySymbol(GPBExceptionMessage);
 #endif  // DEBUG
 
 static NSString *const kGPBDataCoderKey = @"GPBData";
 
-#ifndef _GPBCompileAssert
-  #if __has_feature(c_static_assert) || __has_extension(c_static_assert)
-    #define _GPBCompileAssert(test, msg) _Static_assert((test), #msg)
-  #else
-    // Pre-Xcode 7 support.
-    #define _GPBCompileAssertSymbolInner(line, msg) _GPBCompileAssert ## line ## __ ## msg
-    #define _GPBCompileAssertSymbol(line, msg) _GPBCompileAssertSymbolInner(line, msg)
-    #define _GPBCompileAssert(test, msg) \
-        typedef char _GPBCompileAssertSymbol(__LINE__, msg) [ ((test) ? 1 : -1) ]
-  #endif  // __has_feature(c_static_assert) || __has_extension(c_static_assert)
-#endif // _GPBCompileAssert
-
 //
 // 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.
 //
 
 @interface GPBMessage () {
@@ skipping 482 matching lines @@
   }
   return array;
 }
 
 // This is like GPBGetObjectIvarWithField(), but for arrays, it should
 // only be used to wire the method into the class.
 static id GetArrayIvarWithField(GPBMessage *self, GPBFieldDescriptor *field) {
   id array = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
   if (!array) {
     // Check again after getting the lock.
+    GPBPrepareReadOnlySemaphore(self);
     dispatch_semaphore_wait(self->readOnlySemaphore_, DISPATCH_TIME_FOREVER);
     array = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
     if (!array) {
       array = CreateArrayForField(field, self);
       GPBSetAutocreatedRetainedObjectIvarWithField(self, field, array);
     }
     dispatch_semaphore_signal(self->readOnlySemaphore_);
   }
   return array;
 }
@@ skipping 10 matching lines @@
   }
   return dict;
 }
 
 // This is like GPBGetObjectIvarWithField(), but for maps, it should
 // only be used to wire the method into the class.
 static id GetMapIvarWithField(GPBMessage *self, GPBFieldDescriptor *field) {
   id dict = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
   if (!dict) {
     // Check again after getting the lock.
+    GPBPrepareReadOnlySemaphore(self);
     dispatch_semaphore_wait(self->readOnlySemaphore_, DISPATCH_TIME_FOREVER);
     dict = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
     if (!dict) {
       dict = CreateMapForField(field, self);
       GPBSetAutocreatedRetainedObjectIvarWithField(self, field, dict);
     }
     dispatch_semaphore_signal(self->readOnlySemaphore_);
   }
   return dict;
 }
@@ skipping 171 matching lines @@
     // it supports unknowns/etc.
     fileDescriptor =
         [[GPBFileDescriptor alloc] initWithPackage:@"internal"
                                             syntax:GPBFileSyntaxProto2];
 
     descriptor = [GPBDescriptor allocDescriptorForClass:[GPBMessage class]
                                               rootClass:Nil
                                                    file:fileDescriptor
                                                  fields:NULL
                                              fieldCount:0
-                                                 oneofs:NULL
-                                             oneofCount:0
-                                                  enums:NULL
-                                              enumCount:0
-                                                 ranges:NULL
-                                             rangeCount:0
                                             storageSize:0
-                                             wireFormat:NO];
+                                                  flags:0];
   }
   return descriptor;
 }
 
 + (instancetype)message {
   return [[[self alloc] init] autorelease];
 }
 
 - (instancetype)init {
   if ((self = [super init])) {
     messageStorage_ = (GPBMessage_StoragePtr)(
         ((uint8_t *)self) + class_getInstanceSize([self class]));
-
-    readOnlySemaphore_ = dispatch_semaphore_create(1);
   }
 
   return self;
 }
 
 - (instancetype)initWithData:(NSData *)data error:(NSError **)errorPtr {
   return [self initWithData:data extensionRegistry:nil error:errorPtr];
 }
 
 - (instancetype)initWithData:(NSData *)data
@@ skipping 55 matching lines @@
       }
     }
 #endif
   }
   return self;
 }
 
 - (void)dealloc {
   [self internalClear:NO];
   NSCAssert(!autocreator_, @"Autocreator was not cleared before dealloc.");
+  if (readOnlySemaphore_) {
+    dispatch_release(readOnlySemaphore_);
+  }
   [super dealloc];
 }
 
 - (void)copyFieldsInto:(GPBMessage *)message
                   zone:(NSZone *)zone
             descriptor:(GPBDescriptor *)descriptor {
   // Copy all the storage...
   memcpy(message->messageStorage_, messageStorage_, descriptor->storageSize_);
 
   GPBFileSyntax syntax = descriptor.file.syntax;
@@ skipping 817 matching lines @@
   // No default for repeated.
   if (extension.isRepeated) {
     return nil;
   }
   // Non messages get their default.
   if (!GPBExtensionIsMessage(extension)) {
     return extension.defaultValue;
   }
 
   // Check for an autocreated value.
+  GPBPrepareReadOnlySemaphore(self);
   dispatch_semaphore_wait(readOnlySemaphore_, DISPATCH_TIME_FOREVER);
   value = [autocreatedExtensionMap_ objectForKey:extension];
   if (!value) {
     // Auto create the message extensions to match normal fields.
     value = CreateMessageWithAutocreatorForExtension(extension.msgClass, self,
                                                      extension);
 
     if (autocreatedExtensionMap_ == nil) {
       autocreatedExtensionMap_ = [[NSMutableDictionary alloc] init];
     }
@@ skipping 191 matching lines @@
                                              error:(NSError **)errorPtr {
   GPBMessage *message = [[[self alloc] init] autorelease];
   @try {
     [message mergeDelimitedFromCodedInputStream:input
                               extensionRegistry:extensionRegistry];
     if (errorPtr) {
       *errorPtr = nil;
     }
   }
   @catch (NSException *exception) {
-    [message release];
     message = nil;
     if (errorPtr) {
       *errorPtr = MessageErrorWithReason(GPBMessageErrorCodeMalformedData,
                                          exception.reason);
     }
   }
 #ifdef DEBUG
   if (message && !message.initialized) {
-    [message release];
     message = nil;
     if (errorPtr) {
       *errorPtr = MessageError(GPBMessageErrorCodeMissingRequiredField, nil);
     }
   }
 #endif
   return message;
 }
 
 #pragma mark - Unknown Field Support
@@ skipping 655 matching lines @@
       }
       if (!selfHas) {
         // Same has values, was no, nothing else to check for this field.
         continue;
       }
       // Now compare the values.
       GPBDataType fieldDataType = GPBGetFieldDataType(field);
       size_t fieldOffset = field->description_->offset;
       switch (fieldDataType) {
         case GPBDataTypeBool: {
-          BOOL *selfValPtr = (BOOL *)&selfStorage[fieldOffset];
-          BOOL *otherValPtr = (BOOL *)&otherStorage[fieldOffset];
-          if (*selfValPtr != *otherValPtr) {
+          // Bools are stored in has_bits to avoid needing explicit space in
+          // the storage structure.
+          // (the field number passed to the HasIvar helper doesn't really
+          // matter since the offset is never negative)
+          BOOL selfValue = GPBGetHasIvar(self, (int32_t)(fieldOffset), 0);
+          BOOL otherValue = GPBGetHasIvar(other, (int32_t)(fieldOffset), 0);
+          if (selfValue != otherValue) {
             return NO;
           }
           break;
         }
         case GPBDataTypeSFixed32:
         case GPBDataTypeInt32:
         case GPBDataTypeSInt32:
         case GPBDataTypeEnum:
         case GPBDataTypeFixed32:
         case GPBDataTypeUInt32:
@@ skipping 88 matching lines @@
         result = prime * result + count;
       }
     } else if (GPBGetHasIvarField(self, field)) {
       // Just using the field number seemed simple/fast, but then a small
       // message class where all the same fields are always set (to different
       // things would end up all with the same hash, so pull in some data).
       GPBDataType fieldDataType = GPBGetFieldDataType(field);
       size_t fieldOffset = field->description_->offset;
       switch (fieldDataType) {
         case GPBDataTypeBool: {
-          BOOL *valPtr = (BOOL *)&storage[fieldOffset];
-          result = prime * result + *valPtr;
+          // Bools are stored in has_bits to avoid needing explicit space in
+          // the storage structure.
+          // (the field number passed to the HasIvar helper doesn't really
+          // matter since the offset is never negative)
+          BOOL value = GPBGetHasIvar(self, (int32_t)(fieldOffset), 0);
+          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);
@@ skipping 343 matching lines @@
                                [obj class],
                                NSStringFromSelector(field->setHasSel_)];
           }
           GPBClearMessageField(obj, field);
         });
         result.encodingSelector = @selector(setBool:);
         break;
       } else {
         GPBOneofDescriptor *oneof = field->containingOneof_;
         if (oneof && (sel == oneof->caseSel_)) {
-          int32_t index = oneof->oneofDescription_->index;
+          int32_t index = GPBFieldHasIndex(field);
           result.impToAdd = imp_implementationWithBlock(^(id obj) {
             return GPBGetHasOneof(obj, index);
           });
           result.encodingSelector = @selector(getEnum);
           break;
         }
       }
     } else {
       // map<>/repeated fields.
       if (sel == field->getSel_) {
@@ skipping 74 matching lines @@
 }
 
 #pragma mark - KVC Support
 
 + (BOOL)accessInstanceVariablesDirectly {
   // Make sure KVC doesn't use instance variables.
   return NO;
 }
 
 @end