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

third_party/protobuf/objectivec/GPBArray.m

 // Protocol Buffers - Google's data interchange format
 // Copyright 2015 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 57 matching lines @@
 //%@implementation GPB##NAME##Array {
 //% @package
 //%  TYPE *_values;
 //%  NSUInteger _count;
 //%  NSUInteger _capacity;
 //%}
 //%
 //%@synthesize count = _count;
 //%
 //%+ (instancetype)array {
-//%  return [[[self alloc] initWithValues:NULL count:0] autorelease];
+//%  return [[[self alloc] init] autorelease];
 //%}
 //%
 //%+ (instancetype)arrayWithValue:(TYPE)value {
 //%  // Cast is needed so the compiler knows what class we are invoking initWithValues: on to get
 //%  // the type correct.
 //%  return [[(GPB##NAME##Array*)[self alloc] initWithValues:&value count:1] autorelease];
 //%}
 //%
 //%+ (instancetype)arrayWithValueArray:(GPB##NAME##Array *)array {
 //%  return [[(GPB##NAME##Array*)[self alloc] initWithValueArray:array] autorelease];
 //%}
 //%
 //%+ (instancetype)arrayWithCapacity:(NSUInteger)count {
 //%  return [[[self alloc] initWithCapacity:count] autorelease];
 //%}
 //%
 //%- (instancetype)init {
-//%  return [self initWithValues:NULL count:0];
+//%  self = [super init];
+//%  // No work needed;
+//%  return self;
 //%}
 //%
 //%- (instancetype)initWithValueArray:(GPB##NAME##Array *)array {
 //%  return [self initWithValues:array->_values count:array->_count];
 //%}
 //%
 //%- (instancetype)initWithValues:(const TYPE [])values count:(NSUInteger)count {
-//%  self = [super init];
+//%  self = [self init];
 //%  if (self) {
 //%    if (count && values) {
-//%      _values = malloc(count * sizeof(TYPE));
-//%      if (values != NULL) {
+//%      _values = reallocf(_values, count * sizeof(TYPE));
+//%      if (_values != NULL) {
 //%        _capacity = count;
 //%        memcpy(_values, values, count * sizeof(TYPE));
 //%        _count = count;
 //%      } else {
 //%        [self release];
 //%        [NSException raise:NSMallocException
 //%                    format:@"Failed to allocate %lu bytes",
 //%                           (unsigned long)(count * sizeof(TYPE))];
 //%      }
 //%    }
@@ skipping 173 matching lines @@
 @implementation GPBInt32Array {
  @package
   int32_t *_values;
   NSUInteger _count;
   NSUInteger _capacity;
 }
 
 @synthesize count = _count;
 
 + (instancetype)array {
-  return [[[self alloc] initWithValues:NULL count:0] autorelease];
+  return [[[self alloc] init] autorelease];
 }
 
 + (instancetype)arrayWithValue:(int32_t)value {
   // Cast is needed so the compiler knows what class we are invoking initWithValues: on to get
   // the type correct.
   return [[(GPBInt32Array*)[self alloc] initWithValues:&value count:1] autorelease];
 }
 
 + (instancetype)arrayWithValueArray:(GPBInt32Array *)array {
   return [[(GPBInt32Array*)[self alloc] initWithValueArray:array] autorelease];
 }
 
 + (instancetype)arrayWithCapacity:(NSUInteger)count {
   return [[[self alloc] initWithCapacity:count] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL count:0];
+  self = [super init];
+  // No work needed;
+  return self;
 }
 
 - (instancetype)initWithValueArray:(GPBInt32Array *)array {
   return [self initWithValues:array->_values count:array->_count];
 }
 
 - (instancetype)initWithValues:(const int32_t [])values count:(NSUInteger)count {
-  self = [super init];
+  self = [self init];
   if (self) {
     if (count && values) {
-      _values = malloc(count * sizeof(int32_t));
-      if (values != NULL) {
+      _values = reallocf(_values, count * sizeof(int32_t));
+      if (_values != NULL) {
         _capacity = count;
         memcpy(_values, values, count * sizeof(int32_t));
         _count = count;
       } else {
         [self release];
         [NSException raise:NSMallocException
                     format:@"Failed to allocate %lu bytes",
                            (unsigned long)(count * sizeof(int32_t))];
       }
     }
@@ skipping 194 matching lines @@
 @implementation GPBUInt32Array {
  @package
   uint32_t *_values;
   NSUInteger _count;
   NSUInteger _capacity;
 }
 
 @synthesize count = _count;
 
 + (instancetype)array {
-  return [[[self alloc] initWithValues:NULL count:0] autorelease];
+  return [[[self alloc] init] autorelease];
 }
 
 + (instancetype)arrayWithValue:(uint32_t)value {
   // Cast is needed so the compiler knows what class we are invoking initWithValues: on to get
   // the type correct.
   return [[(GPBUInt32Array*)[self alloc] initWithValues:&value count:1] autorelease];
 }
 
 + (instancetype)arrayWithValueArray:(GPBUInt32Array *)array {
   return [[(GPBUInt32Array*)[self alloc] initWithValueArray:array] autorelease];
 }
 
 + (instancetype)arrayWithCapacity:(NSUInteger)count {
   return [[[self alloc] initWithCapacity:count] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL count:0];
+  self = [super init];
+  // No work needed;
+  return self;
 }
 
 - (instancetype)initWithValueArray:(GPBUInt32Array *)array {
   return [self initWithValues:array->_values count:array->_count];
 }
 
 - (instancetype)initWithValues:(const uint32_t [])values count:(NSUInteger)count {
-  self = [super init];
+  self = [self init];
   if (self) {
     if (count && values) {
-      _values = malloc(count * sizeof(uint32_t));
-      if (values != NULL) {
+      _values = reallocf(_values, count * sizeof(uint32_t));
+      if (_values != NULL) {
         _capacity = count;
         memcpy(_values, values, count * sizeof(uint32_t));
         _count = count;
       } else {
         [self release];
         [NSException raise:NSMallocException
                     format:@"Failed to allocate %lu bytes",
                            (unsigned long)(count * sizeof(uint32_t))];
       }
     }
@@ skipping 194 matching lines @@
 @implementation GPBInt64Array {
  @package
   int64_t *_values;
   NSUInteger _count;
   NSUInteger _capacity;
 }
 
 @synthesize count = _count;
 
 + (instancetype)array {
-  return [[[self alloc] initWithValues:NULL count:0] autorelease];
+  return [[[self alloc] init] autorelease];
 }
 
 + (instancetype)arrayWithValue:(int64_t)value {
   // Cast is needed so the compiler knows what class we are invoking initWithValues: on to get
   // the type correct.
   return [[(GPBInt64Array*)[self alloc] initWithValues:&value count:1] autorelease];
 }
 
 + (instancetype)arrayWithValueArray:(GPBInt64Array *)array {
   return [[(GPBInt64Array*)[self alloc] initWithValueArray:array] autorelease];
 }
 
 + (instancetype)arrayWithCapacity:(NSUInteger)count {
   return [[[self alloc] initWithCapacity:count] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL count:0];
+  self = [super init];
+  // No work needed;
+  return self;
 }
 
 - (instancetype)initWithValueArray:(GPBInt64Array *)array {
   return [self initWithValues:array->_values count:array->_count];
 }
 
 - (instancetype)initWithValues:(const int64_t [])values count:(NSUInteger)count {
-  self = [super init];
+  self = [self init];
   if (self) {
     if (count && values) {
-      _values = malloc(count * sizeof(int64_t));
-      if (values != NULL) {
+      _values = reallocf(_values, count * sizeof(int64_t));
+      if (_values != NULL) {
         _capacity = count;
         memcpy(_values, values, count * sizeof(int64_t));
         _count = count;
       } else {
         [self release];
         [NSException raise:NSMallocException
                     format:@"Failed to allocate %lu bytes",
                            (unsigned long)(count * sizeof(int64_t))];
       }
     }
@@ skipping 194 matching lines @@
 @implementation GPBUInt64Array {
  @package
   uint64_t *_values;
   NSUInteger _count;
   NSUInteger _capacity;
 }
 
 @synthesize count = _count;
 
 + (instancetype)array {
-  return [[[self alloc] initWithValues:NULL count:0] autorelease];
+  return [[[self alloc] init] autorelease];
 }
 
 + (instancetype)arrayWithValue:(uint64_t)value {
   // Cast is needed so the compiler knows what class we are invoking initWithValues: on to get
   // the type correct.
   return [[(GPBUInt64Array*)[self alloc] initWithValues:&value count:1] autorelease];
 }
 
 + (instancetype)arrayWithValueArray:(GPBUInt64Array *)array {
   return [[(GPBUInt64Array*)[self alloc] initWithValueArray:array] autorelease];
 }
 
 + (instancetype)arrayWithCapacity:(NSUInteger)count {
   return [[[self alloc] initWithCapacity:count] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL count:0];
+  self = [super init];
+  // No work needed;
+  return self;
 }
 
 - (instancetype)initWithValueArray:(GPBUInt64Array *)array {
   return [self initWithValues:array->_values count:array->_count];
 }
 
 - (instancetype)initWithValues:(const uint64_t [])values count:(NSUInteger)count {
-  self = [super init];
+  self = [self init];
   if (self) {
     if (count && values) {
-      _values = malloc(count * sizeof(uint64_t));
-      if (values != NULL) {
+      _values = reallocf(_values, count * sizeof(uint64_t));
+      if (_values != NULL) {
         _capacity = count;
         memcpy(_values, values, count * sizeof(uint64_t));
         _count = count;
       } else {
         [self release];
         [NSException raise:NSMallocException
                     format:@"Failed to allocate %lu bytes",
                            (unsigned long)(count * sizeof(uint64_t))];
       }
     }
@@ skipping 194 matching lines @@
 @implementation GPBFloatArray {
  @package
   float *_values;
   NSUInteger _count;
   NSUInteger _capacity;
 }
 
 @synthesize count = _count;
 
 + (instancetype)array {
-  return [[[self alloc] initWithValues:NULL count:0] autorelease];
+  return [[[self alloc] init] autorelease];
 }
 
 + (instancetype)arrayWithValue:(float)value {
   // Cast is needed so the compiler knows what class we are invoking initWithValues: on to get
   // the type correct.
   return [[(GPBFloatArray*)[self alloc] initWithValues:&value count:1] autorelease];
 }
 
 + (instancetype)arrayWithValueArray:(GPBFloatArray *)array {
   return [[(GPBFloatArray*)[self alloc] initWithValueArray:array] autorelease];
 }
 
 + (instancetype)arrayWithCapacity:(NSUInteger)count {
   return [[[self alloc] initWithCapacity:count] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL count:0];
+  self = [super init];
+  // No work needed;
+  return self;
 }
 
 - (instancetype)initWithValueArray:(GPBFloatArray *)array {
   return [self initWithValues:array->_values count:array->_count];
 }
 
 - (instancetype)initWithValues:(const float [])values count:(NSUInteger)count {
-  self = [super init];
+  self = [self init];
   if (self) {
     if (count && values) {
-      _values = malloc(count * sizeof(float));
-      if (values != NULL) {
+      _values = reallocf(_values, count * sizeof(float));
+      if (_values != NULL) {
         _capacity = count;
         memcpy(_values, values, count * sizeof(float));
         _count = count;
       } else {
         [self release];
         [NSException raise:NSMallocException
                     format:@"Failed to allocate %lu bytes",
                            (unsigned long)(count * sizeof(float))];
       }
     }
@@ skipping 194 matching lines @@
 @implementation GPBDoubleArray {
  @package
   double *_values;
   NSUInteger _count;
   NSUInteger _capacity;
 }
 
 @synthesize count = _count;
 
 + (instancetype)array {
-  return [[[self alloc] initWithValues:NULL count:0] autorelease];
+  return [[[self alloc] init] autorelease];
 }
 
 + (instancetype)arrayWithValue:(double)value {
   // Cast is needed so the compiler knows what class we are invoking initWithValues: on to get
   // the type correct.
   return [[(GPBDoubleArray*)[self alloc] initWithValues:&value count:1] autorelease];
 }
 
 + (instancetype)arrayWithValueArray:(GPBDoubleArray *)array {
   return [[(GPBDoubleArray*)[self alloc] initWithValueArray:array] autorelease];
 }
 
 + (instancetype)arrayWithCapacity:(NSUInteger)count {
   return [[[self alloc] initWithCapacity:count] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL count:0];
+  self = [super init];
+  // No work needed;
+  return self;
 }
 
 - (instancetype)initWithValueArray:(GPBDoubleArray *)array {
   return [self initWithValues:array->_values count:array->_count];
 }
 
 - (instancetype)initWithValues:(const double [])values count:(NSUInteger)count {
-  self = [super init];
+  self = [self init];
   if (self) {
     if (count && values) {
-      _values = malloc(count * sizeof(double));
-      if (values != NULL) {
+      _values = reallocf(_values, count * sizeof(double));
+      if (_values != NULL) {
         _capacity = count;
         memcpy(_values, values, count * sizeof(double));
         _count = count;
       } else {
         [self release];
         [NSException raise:NSMallocException
                     format:@"Failed to allocate %lu bytes",
                            (unsigned long)(count * sizeof(double))];
       }
     }
@@ skipping 194 matching lines @@
 @implementation GPBBoolArray {
  @package
   BOOL *_values;
   NSUInteger _count;
   NSUInteger _capacity;
 }
 
 @synthesize count = _count;
 
 + (instancetype)array {
-  return [[[self alloc] initWithValues:NULL count:0] autorelease];
+  return [[[self alloc] init] autorelease];
 }
 
 + (instancetype)arrayWithValue:(BOOL)value {
   // Cast is needed so the compiler knows what class we are invoking initWithValues: on to get
   // the type correct.
   return [[(GPBBoolArray*)[self alloc] initWithValues:&value count:1] autorelease];
 }
 
 + (instancetype)arrayWithValueArray:(GPBBoolArray *)array {
   return [[(GPBBoolArray*)[self alloc] initWithValueArray:array] autorelease];
 }
 
 + (instancetype)arrayWithCapacity:(NSUInteger)count {
   return [[[self alloc] initWithCapacity:count] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL count:0];
+  self = [super init];
+  // No work needed;
+  return self;
 }
 
 - (instancetype)initWithValueArray:(GPBBoolArray *)array {
   return [self initWithValues:array->_values count:array->_count];
 }
 
 - (instancetype)initWithValues:(const BOOL [])values count:(NSUInteger)count {
-  self = [super init];
+  self = [self init];
   if (self) {
     if (count && values) {
-      _values = malloc(count * sizeof(BOOL));
-      if (values != NULL) {
+      _values = reallocf(_values, count * sizeof(BOOL));
+      if (_values != NULL) {
         _capacity = count;
         memcpy(_values, values, count * sizeof(BOOL));
         _count = count;
       } else {
         [self release];
         [NSException raise:NSMallocException
                     format:@"Failed to allocate %lu bytes",
                            (unsigned long)(count * sizeof(BOOL))];
       }
     }
@@ skipping 195 matching lines @@
   GPBEnumValidationFunc _validationFunc;
   int32_t *_values;
   NSUInteger _count;
   NSUInteger _capacity;
 }
 
 @synthesize count = _count;
 @synthesize validationFunc = _validationFunc;
 
 + (instancetype)array {
-  return [[[self alloc] initWithValidationFunction:NULL
-                                         rawValues:NULL
-                                             count:0] autorelease];
+  return [[[self alloc] initWithValidationFunction:NULL] autorelease];
 }
 
 + (instancetype)arrayWithValidationFunction:(GPBEnumValidationFunc)func {
-  return [[[self alloc] initWithValidationFunction:func
-                                         rawValues:NULL
-                                             count:0] autorelease];
+  return [[[self alloc] initWithValidationFunction:func] autorelease];
 }
 
 + (instancetype)arrayWithValidationFunction:(GPBEnumValidationFunc)func
                                    rawValue:(int32_t)value {
   return [[[self alloc] initWithValidationFunction:func
                                          rawValues:&value
                                              count:1] autorelease];
 }
 
 + (instancetype)arrayWithValueArray:(GPBEnumArray *)array {
   return [[(GPBEnumArray*)[self alloc] initWithValueArray:array] autorelease];
 }
 
 + (instancetype)arrayWithValidationFunction:(GPBEnumValidationFunc)func
                                    capacity:(NSUInteger)count {
   return [[[self alloc] initWithValidationFunction:func capacity:count] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValidationFunction:NULL rawValues:NULL count:0];
+  return [self initWithValidationFunction:NULL];
 }
 
 - (instancetype)initWithValueArray:(GPBEnumArray *)array {
   return [self initWithValidationFunction:array->_validationFunc
                                 rawValues:array->_values
                                     count:array->_count];
 }
 
 - (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func {
-  return [self initWithValidationFunction:func rawValues:NULL count:0];
+  self = [super init];
+  if (self) {
+    _validationFunc = (func != NULL ? func : ArrayDefault_IsValidValue);
+  }
+  return self;
 }
 
 - (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func
                                  rawValues:(const int32_t [])values
                                      count:(NSUInteger)count {
-  self = [super init];
+  self = [self initWithValidationFunction:func];
   if (self) {
-    _validationFunc = (func != NULL ? func : ArrayDefault_IsValidValue);
     if (count && values) {
-      _values = malloc(count * sizeof(int32_t));
-      if (values != NULL) {
+      _values = reallocf(_values, count * sizeof(int32_t));
+      if (_values != NULL) {
         _capacity = count;
         memcpy(_values, values, count * sizeof(int32_t));
         _count = count;
       } else {
         [self release];
         [NSException raise:NSMallocException
                     format:@"Failed to allocate %lu bytes",
                            (unsigned long)(count * sizeof(int32_t))];
       }
     }
   }
   return self;
 }
 
 - (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func
                                   capacity:(NSUInteger)count {
-  self = [self initWithValidationFunction:func rawValues:NULL count:0];
+  self = [self initWithValidationFunction:func];
   if (self && count) {
     [self internalResizeToCapacity:count];
   }
   return self;
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBEnumArray allocWithZone:zone]
              initWithValidationFunction:_validationFunc
                               rawValues:_values
@@ skipping 415 matching lines @@
 - (void)enumerateObjectsUsingBlock:(void (^)(id obj, NSUInteger idx, BOOL *stop))block {
   [_array enumerateObjectsUsingBlock:block];
 }
 
 - (void)enumerateObjectsWithOptions:(NSEnumerationOptions)opts
                          usingBlock:(void (^)(id obj, NSUInteger idx, BOOL *stop))block {
   [_array enumerateObjectsWithOptions:opts usingBlock:block];
 }
 
 @end