third_party/protobuf: Update to HEAD (83d681ee2c)

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 14 matching lines @@
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (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 "GPBArray_PackagePrivate.h"
 
 #import "GPBMessage_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"
+
 // Mutable arrays use an internal buffer that can always hold a multiple of this elements.
 #define kChunkSize 16
 #define CapacityFromCount(x) (((x / kChunkSize) + 1) * kChunkSize)
 
 static BOOL ArrayDefault_IsValidValue(int32_t value) {
   // Anything but the bad value marker is allowed.
   return (value != kGPBUnrecognizedEnumeratorValue);
 }
 
 //%PDDM-DEFINE VALIDATE_RANGE(INDEX, COUNT)
@@ skipping 106 matching lines @@
 
 //%PDDM-DEFINE ARRAY_IMMUTABLE_CORE(NAME, TYPE, ACCESSOR_NAME, FORMAT)
 //%- (void)dealloc {
 //%  NSAssert(!_autocreator,
 //%           @"%@: Autocreator must be cleared before release, autocreator: %@",
 //%           [self class], _autocreator);
 //%  free(_values);
 //%  [super dealloc];
 //%}
 //%
-//%- (BOOL)isEqual:(GPB##NAME##Array *)other {
+//%- (BOOL)isEqual:(id)other {
 //%  if (self == other) {
 //%    return YES;
 //%  }
 //%  if (![other isKindOfClass:[GPB##NAME##Array class]]) {
 //%    return NO;
 //%  }
-//%  return (_count == other->_count
-//%          && memcmp(_values, other->_values, (_count * sizeof(TYPE))) == 0);
+//%  GPB##NAME##Array *otherArray = other;
+//%  return (_count == otherArray->_count
+//%          && memcmp(_values, otherArray->_values, (_count * sizeof(TYPE))) == 0);
 //%}
 //%
 //%- (NSUInteger)hash {
 //%  // Follow NSArray's lead, and use the count as the hash.
 //%  return _count;
 //%}
 //%
 //%- (NSString *)description {
 //%  NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> { ", [self class], self];
 //%  for (NSUInteger i = 0, count = _count; i < count; ++i) {
 //%    if (i == 0) {
 //%      [result appendFormat:@"##FORMAT##", _values[i]];
 //%    } else {
 //%      [result appendFormat:@", ##FORMAT##", _values[i]];
 //%    }
 //%  }
 //%  [result appendFormat:@" }"];
 //%  return result;
 //%}
 //%
 //%- (void)enumerate##ACCESSOR_NAME##ValuesWithBlock:(void (^)(TYPE value, NSUInteger idx, BOOL *stop))block {
-//%  [self enumerate##ACCESSOR_NAME##ValuesWithOptions:0 usingBlock:block];
+//%  [self enumerate##ACCESSOR_NAME##ValuesWithOptions:(NSEnumerationOptions)0 usingBlock:block];
 //%}
 //%
 //%- (void)enumerate##ACCESSOR_NAME##ValuesWithOptions:(NSEnumerationOptions)opts
 //%                  ACCESSOR_NAME$S      usingBlock:(void (^)(TYPE value, NSUInteger idx, BOOL *stop))block {
 //%  // NSEnumerationConcurrent isn't currently supported (and Apple's docs say that is ok).
 //%  BOOL stop = NO;
 //%  if ((opts & NSEnumerationReverse) == 0) {
 //%    for (NSUInteger i = 0, count = _count; i < count; ++i) {
 //%      block(_values[i], i, &stop);
 //%      if (stop) break;
@@ skipping 159 matching lines @@
 }
 
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   free(_values);
   [super dealloc];
 }
 
-- (BOOL)isEqual:(GPBInt32Array *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBInt32Array class]]) {
     return NO;
   }
-  return (_count == other->_count
-          && memcmp(_values, other->_values, (_count * sizeof(int32_t))) == 0);
+  GPBInt32Array *otherArray = other;
+  return (_count == otherArray->_count
+          && memcmp(_values, otherArray->_values, (_count * sizeof(int32_t))) == 0);
 }
 
 - (NSUInteger)hash {
   // Follow NSArray's lead, and use the count as the hash.
   return _count;
 }
 
 - (NSString *)description {
   NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> { ", [self class], self];
   for (NSUInteger i = 0, count = _count; i < count; ++i) {
     if (i == 0) {
       [result appendFormat:@"%d", _values[i]];
     } else {
       [result appendFormat:@", %d", _values[i]];
     }
   }
   [result appendFormat:@" }"];
   return result;
 }
 
 - (void)enumerateValuesWithBlock:(void (^)(int32_t value, NSUInteger idx, BOOL *stop))block {
-  [self enumerateValuesWithOptions:0 usingBlock:block];
+  [self enumerateValuesWithOptions:(NSEnumerationOptions)0 usingBlock:block];
 }
 
 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts
                         usingBlock:(void (^)(int32_t value, NSUInteger idx, BOOL *stop))block {
   // NSEnumerationConcurrent isn't currently supported (and Apple's docs say that is ok).
   BOOL stop = NO;
   if ((opts & NSEnumerationReverse) == 0) {
     for (NSUInteger i = 0, count = _count; i < count; ++i) {
       block(_values[i], i, &stop);
       if (stop) break;
@@ skipping 196 matching lines @@
 }
 
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   free(_values);
   [super dealloc];
 }
 
-- (BOOL)isEqual:(GPBUInt32Array *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBUInt32Array class]]) {
     return NO;
   }
-  return (_count == other->_count
-          && memcmp(_values, other->_values, (_count * sizeof(uint32_t))) == 0);
+  GPBUInt32Array *otherArray = other;
+  return (_count == otherArray->_count
+          && memcmp(_values, otherArray->_values, (_count * sizeof(uint32_t))) == 0);
 }
 
 - (NSUInteger)hash {
   // Follow NSArray's lead, and use the count as the hash.
   return _count;
 }
 
 - (NSString *)description {
   NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> { ", [self class], self];
   for (NSUInteger i = 0, count = _count; i < count; ++i) {
     if (i == 0) {
       [result appendFormat:@"%u", _values[i]];
     } else {
       [result appendFormat:@", %u", _values[i]];
     }
   }
   [result appendFormat:@" }"];
   return result;
 }
 
 - (void)enumerateValuesWithBlock:(void (^)(uint32_t value, NSUInteger idx, BOOL *stop))block {
-  [self enumerateValuesWithOptions:0 usingBlock:block];
+  [self enumerateValuesWithOptions:(NSEnumerationOptions)0 usingBlock:block];
 }
 
 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts
                         usingBlock:(void (^)(uint32_t value, NSUInteger idx, BOOL *stop))block {
   // NSEnumerationConcurrent isn't currently supported (and Apple's docs say that is ok).
   BOOL stop = NO;
   if ((opts & NSEnumerationReverse) == 0) {
     for (NSUInteger i = 0, count = _count; i < count; ++i) {
       block(_values[i], i, &stop);
       if (stop) break;
@@ skipping 196 matching lines @@
 }
 
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   free(_values);
   [super dealloc];
 }
 
-- (BOOL)isEqual:(GPBInt64Array *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBInt64Array class]]) {
     return NO;
   }
-  return (_count == other->_count
-          && memcmp(_values, other->_values, (_count * sizeof(int64_t))) == 0);
+  GPBInt64Array *otherArray = other;
+  return (_count == otherArray->_count
+          && memcmp(_values, otherArray->_values, (_count * sizeof(int64_t))) == 0);
 }
 
 - (NSUInteger)hash {
   // Follow NSArray's lead, and use the count as the hash.
   return _count;
 }
 
 - (NSString *)description {
   NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> { ", [self class], self];
   for (NSUInteger i = 0, count = _count; i < count; ++i) {
     if (i == 0) {
       [result appendFormat:@"%lld", _values[i]];
     } else {
       [result appendFormat:@", %lld", _values[i]];
     }
   }
   [result appendFormat:@" }"];
   return result;
 }
 
 - (void)enumerateValuesWithBlock:(void (^)(int64_t value, NSUInteger idx, BOOL *stop))block {
-  [self enumerateValuesWithOptions:0 usingBlock:block];
+  [self enumerateValuesWithOptions:(NSEnumerationOptions)0 usingBlock:block];
 }
 
 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts
                         usingBlock:(void (^)(int64_t value, NSUInteger idx, BOOL *stop))block {
   // NSEnumerationConcurrent isn't currently supported (and Apple's docs say that is ok).
   BOOL stop = NO;
   if ((opts & NSEnumerationReverse) == 0) {
     for (NSUInteger i = 0, count = _count; i < count; ++i) {
       block(_values[i], i, &stop);
       if (stop) break;
@@ skipping 196 matching lines @@
 }
 
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   free(_values);
   [super dealloc];
 }
 
-- (BOOL)isEqual:(GPBUInt64Array *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBUInt64Array class]]) {
     return NO;
   }
-  return (_count == other->_count
-          && memcmp(_values, other->_values, (_count * sizeof(uint64_t))) == 0);
+  GPBUInt64Array *otherArray = other;
+  return (_count == otherArray->_count
+          && memcmp(_values, otherArray->_values, (_count * sizeof(uint64_t))) == 0);
 }
 
 - (NSUInteger)hash {
   // Follow NSArray's lead, and use the count as the hash.
   return _count;
 }
 
 - (NSString *)description {
   NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> { ", [self class], self];
   for (NSUInteger i = 0, count = _count; i < count; ++i) {
     if (i == 0) {
       [result appendFormat:@"%llu", _values[i]];
     } else {
       [result appendFormat:@", %llu", _values[i]];
     }
   }
   [result appendFormat:@" }"];
   return result;
 }
 
 - (void)enumerateValuesWithBlock:(void (^)(uint64_t value, NSUInteger idx, BOOL *stop))block {
-  [self enumerateValuesWithOptions:0 usingBlock:block];
+  [self enumerateValuesWithOptions:(NSEnumerationOptions)0 usingBlock:block];
 }
 
 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts
                         usingBlock:(void (^)(uint64_t value, NSUInteger idx, BOOL *stop))block {
   // NSEnumerationConcurrent isn't currently supported (and Apple's docs say that is ok).
   BOOL stop = NO;
   if ((opts & NSEnumerationReverse) == 0) {
     for (NSUInteger i = 0, count = _count; i < count; ++i) {
       block(_values[i], i, &stop);
       if (stop) break;
@@ skipping 196 matching lines @@
 }
 
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   free(_values);
   [super dealloc];
 }
 
-- (BOOL)isEqual:(GPBFloatArray *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBFloatArray class]]) {
     return NO;
   }
-  return (_count == other->_count
-          && memcmp(_values, other->_values, (_count * sizeof(float))) == 0);
+  GPBFloatArray *otherArray = other;
+  return (_count == otherArray->_count
+          && memcmp(_values, otherArray->_values, (_count * sizeof(float))) == 0);
 }
 
 - (NSUInteger)hash {
   // Follow NSArray's lead, and use the count as the hash.
   return _count;
 }
 
 - (NSString *)description {
   NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> { ", [self class], self];
   for (NSUInteger i = 0, count = _count; i < count; ++i) {
     if (i == 0) {
       [result appendFormat:@"%f", _values[i]];
     } else {
       [result appendFormat:@", %f", _values[i]];
     }
   }
   [result appendFormat:@" }"];
   return result;
 }
 
 - (void)enumerateValuesWithBlock:(void (^)(float value, NSUInteger idx, BOOL *stop))block {
-  [self enumerateValuesWithOptions:0 usingBlock:block];
+  [self enumerateValuesWithOptions:(NSEnumerationOptions)0 usingBlock:block];
 }
 
 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts
                         usingBlock:(void (^)(float value, NSUInteger idx, BOOL *stop))block {
   // NSEnumerationConcurrent isn't currently supported (and Apple's docs say that is ok).
   BOOL stop = NO;
   if ((opts & NSEnumerationReverse) == 0) {
     for (NSUInteger i = 0, count = _count; i < count; ++i) {
       block(_values[i], i, &stop);
       if (stop) break;
@@ skipping 196 matching lines @@
 }
 
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   free(_values);
   [super dealloc];
 }
 
-- (BOOL)isEqual:(GPBDoubleArray *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBDoubleArray class]]) {
     return NO;
   }
-  return (_count == other->_count
-          && memcmp(_values, other->_values, (_count * sizeof(double))) == 0);
+  GPBDoubleArray *otherArray = other;
+  return (_count == otherArray->_count
+          && memcmp(_values, otherArray->_values, (_count * sizeof(double))) == 0);
 }
 
 - (NSUInteger)hash {
   // Follow NSArray's lead, and use the count as the hash.
   return _count;
 }
 
 - (NSString *)description {
   NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> { ", [self class], self];
   for (NSUInteger i = 0, count = _count; i < count; ++i) {
     if (i == 0) {
       [result appendFormat:@"%lf", _values[i]];
     } else {
       [result appendFormat:@", %lf", _values[i]];
     }
   }
   [result appendFormat:@" }"];
   return result;
 }
 
 - (void)enumerateValuesWithBlock:(void (^)(double value, NSUInteger idx, BOOL *stop))block {
-  [self enumerateValuesWithOptions:0 usingBlock:block];
+  [self enumerateValuesWithOptions:(NSEnumerationOptions)0 usingBlock:block];
 }
 
 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts
                         usingBlock:(void (^)(double value, NSUInteger idx, BOOL *stop))block {
   // NSEnumerationConcurrent isn't currently supported (and Apple's docs say that is ok).
   BOOL stop = NO;
   if ((opts & NSEnumerationReverse) == 0) {
     for (NSUInteger i = 0, count = _count; i < count; ++i) {
       block(_values[i], i, &stop);
       if (stop) break;
@@ skipping 196 matching lines @@
 }
 
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   free(_values);
   [super dealloc];
 }
 
-- (BOOL)isEqual:(GPBBoolArray *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBBoolArray class]]) {
     return NO;
   }
-  return (_count == other->_count
-          && memcmp(_values, other->_values, (_count * sizeof(BOOL))) == 0);
+  GPBBoolArray *otherArray = other;
+  return (_count == otherArray->_count
+          && memcmp(_values, otherArray->_values, (_count * sizeof(BOOL))) == 0);
 }
 
 - (NSUInteger)hash {
   // Follow NSArray's lead, and use the count as the hash.
   return _count;
 }
 
 - (NSString *)description {
   NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> { ", [self class], self];
   for (NSUInteger i = 0, count = _count; i < count; ++i) {
     if (i == 0) {
       [result appendFormat:@"%d", _values[i]];
     } else {
       [result appendFormat:@", %d", _values[i]];
     }
   }
   [result appendFormat:@" }"];
   return result;
 }
 
 - (void)enumerateValuesWithBlock:(void (^)(BOOL value, NSUInteger idx, BOOL *stop))block {
-  [self enumerateValuesWithOptions:0 usingBlock:block];
+  [self enumerateValuesWithOptions:(NSEnumerationOptions)0 usingBlock:block];
 }
 
 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts
                         usingBlock:(void (^)(BOOL value, NSUInteger idx, BOOL *stop))block {
   // NSEnumerationConcurrent isn't currently supported (and Apple's docs say that is ok).
   BOOL stop = NO;
   if ((opts & NSEnumerationReverse) == 0) {
     for (NSUInteger i = 0, count = _count; i < count; ++i) {
       block(_values[i], i, &stop);
       if (stop) break;
@@ skipping 220 matching lines @@
 // This block of code is generated, do not edit it directly.
 
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   free(_values);
   [super dealloc];
 }
 
-- (BOOL)isEqual:(GPBEnumArray *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBEnumArray class]]) {
     return NO;
   }
-  return (_count == other->_count
-          && memcmp(_values, other->_values, (_count * sizeof(int32_t))) == 0);
+  GPBEnumArray *otherArray = other;
+  return (_count == otherArray->_count
+          && memcmp(_values, otherArray->_values, (_count * sizeof(int32_t))) == 0);
 }
 
 - (NSUInteger)hash {
   // Follow NSArray's lead, and use the count as the hash.
   return _count;
 }
 
 - (NSString *)description {
   NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> { ", [self class], self];
   for (NSUInteger i = 0, count = _count; i < count; ++i) {
     if (i == 0) {
       [result appendFormat:@"%d", _values[i]];
     } else {
       [result appendFormat:@", %d", _values[i]];
     }
   }
   [result appendFormat:@" }"];
   return result;
 }
 
 - (void)enumerateRawValuesWithBlock:(void (^)(int32_t value, NSUInteger idx, BOOL *stop))block {
-  [self enumerateRawValuesWithOptions:0 usingBlock:block];
+  [self enumerateRawValuesWithOptions:(NSEnumerationOptions)0 usingBlock:block];
 }
 
 - (void)enumerateRawValuesWithOptions:(NSEnumerationOptions)opts
                            usingBlock:(void (^)(int32_t value, NSUInteger idx, BOOL *stop))block {
   // NSEnumerationConcurrent isn't currently supported (and Apple's docs say that is ok).
   BOOL stop = NO;
   if ((opts & NSEnumerationReverse) == 0) {
     for (NSUInteger i = 0, count = _count; i < count; ++i) {
       block(_values[i], i, &stop);
       if (stop) break;
@@ skipping 31 matching lines @@
   if (index >= _count) {
     [NSException raise:NSRangeException
                 format:@"Index (%lu) beyond bounds (%lu)",
                        (unsigned long)index, (unsigned long)_count];
   }
 //%PDDM-EXPAND-END VALIDATE_RANGE(index, _count)
   return _values[index];
 }
 
 - (void)enumerateValuesWithBlock:(void (^)(int32_t value, NSUInteger idx, BOOL *stop))block {
-  [self enumerateValuesWithOptions:0 usingBlock:block];
+  [self enumerateValuesWithOptions:(NSEnumerationOptions)0 usingBlock:block];
 }
 
 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts
                         usingBlock:(void (^)(int32_t value, NSUInteger idx, BOOL *stop))block {
   // NSEnumerationConcurrent isn't currently supported (and Apple's docs say that is ok).
   BOOL stop = NO;
   GPBEnumValidationFunc func = _validationFunc;
   if ((opts & NSEnumerationReverse) == 0) {
     int32_t *scan = _values;
     int32_t *end = scan + _count;
@@ skipping 308 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
+
+#pragma clang diagnostic pop