Added Android code
[wl-app.git] / iOS / Pods / Protobuf / objectivec / GPBArray.m
1 // Protocol Buffers - Google's data interchange format
2 // Copyright 2015 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 "GPBArray_PackagePrivate.h"
32
33 #import "GPBMessage_PackagePrivate.h"
34
35 // Direct access is use for speed, to avoid even internally declaring things
36 // read/write, etc. The warning is enabled in the project to ensure code calling
37 // protos can turn on -Wdirect-ivar-access without issues.
38 #pragma clang diagnostic push
39 #pragma clang diagnostic ignored "-Wdirect-ivar-access"
40
41 // Mutable arrays use an internal buffer that can always hold a multiple of this elements.
42 #define kChunkSize 16
43 #define CapacityFromCount(x) (((x / kChunkSize) + 1) * kChunkSize)
44
45 static BOOL ArrayDefault_IsValidValue(int32_t value) {
46   // Anything but the bad value marker is allowed.
47   return (value != kGPBUnrecognizedEnumeratorValue);
48 }
49
50 //%PDDM-DEFINE VALIDATE_RANGE(INDEX, COUNT)
51 //%  if (INDEX >= COUNT) {
52 //%    [NSException raise:NSRangeException
53 //%                format:@"Index (%lu) beyond bounds (%lu)",
54 //%                       (unsigned long)INDEX, (unsigned long)COUNT];
55 //%  }
56 //%PDDM-DEFINE MAYBE_GROW_TO_SET_COUNT(NEW_COUNT)
57 //%  if (NEW_COUNT > _capacity) {
58 //%    [self internalResizeToCapacity:CapacityFromCount(NEW_COUNT)];
59 //%  }
60 //%  _count = NEW_COUNT;
61 //%PDDM-DEFINE SET_COUNT_AND_MAYBE_SHRINK(NEW_COUNT)
62 //%  _count = NEW_COUNT;
63 //%  if ((NEW_COUNT + (2 * kChunkSize)) < _capacity) {
64 //%    [self internalResizeToCapacity:CapacityFromCount(NEW_COUNT)];
65 //%  }
66
67 //
68 // Macros for the common basic cases.
69 //
70
71 //%PDDM-DEFINE ARRAY_INTERFACE_SIMPLE(NAME, TYPE, FORMAT)
72 //%#pragma mark - NAME
73 //%
74 //%@implementation GPB##NAME##Array {
75 //% @package
76 //%  TYPE *_values;
77 //%  NSUInteger _count;
78 //%  NSUInteger _capacity;
79 //%}
80 //%
81 //%@synthesize count = _count;
82 //%
83 //%+ (instancetype)array {
84 //%  return [[[self alloc] init] autorelease];
85 //%}
86 //%
87 //%+ (instancetype)arrayWithValue:(TYPE)value {
88 //%  // Cast is needed so the compiler knows what class we are invoking initWithValues: on to get
89 //%  // the type correct.
90 //%  return [[(GPB##NAME##Array*)[self alloc] initWithValues:&value count:1] autorelease];
91 //%}
92 //%
93 //%+ (instancetype)arrayWithValueArray:(GPB##NAME##Array *)array {
94 //%  return [[(GPB##NAME##Array*)[self alloc] initWithValueArray:array] autorelease];
95 //%}
96 //%
97 //%+ (instancetype)arrayWithCapacity:(NSUInteger)count {
98 //%  return [[[self alloc] initWithCapacity:count] autorelease];
99 //%}
100 //%
101 //%- (instancetype)init {
102 //%  self = [super init];
103 //%  // No work needed;
104 //%  return self;
105 //%}
106 //%
107 //%- (instancetype)initWithValueArray:(GPB##NAME##Array *)array {
108 //%  return [self initWithValues:array->_values count:array->_count];
109 //%}
110 //%
111 //%- (instancetype)initWithValues:(const TYPE [])values count:(NSUInteger)count {
112 //%  self = [self init];
113 //%  if (self) {
114 //%    if (count && values) {
115 //%      _values = reallocf(_values, count * sizeof(TYPE));
116 //%      if (_values != NULL) {
117 //%        _capacity = count;
118 //%        memcpy(_values, values, count * sizeof(TYPE));
119 //%        _count = count;
120 //%      } else {
121 //%        [self release];
122 //%        [NSException raise:NSMallocException
123 //%                    format:@"Failed to allocate %lu bytes",
124 //%                           (unsigned long)(count * sizeof(TYPE))];
125 //%      }
126 //%    }
127 //%  }
128 //%  return self;
129 //%}
130 //%
131 //%- (instancetype)initWithCapacity:(NSUInteger)count {
132 //%  self = [self initWithValues:NULL count:0];
133 //%  if (self && count) {
134 //%    [self internalResizeToCapacity:count];
135 //%  }
136 //%  return self;
137 //%}
138 //%
139 //%- (instancetype)copyWithZone:(NSZone *)zone {
140 //%  return [[GPB##NAME##Array allocWithZone:zone] initWithValues:_values count:_count];
141 //%}
142 //%
143 //%ARRAY_IMMUTABLE_CORE(NAME, TYPE, , FORMAT)
144 //%
145 //%- (TYPE)valueAtIndex:(NSUInteger)index {
146 //%VALIDATE_RANGE(index, _count)
147 //%  return _values[index];
148 //%}
149 //%
150 //%ARRAY_MUTABLE_CORE(NAME, TYPE, , FORMAT)
151 //%@end
152 //%
153
154 //
155 // Some core macros used for both the simple types and Enums.
156 //
157
158 //%PDDM-DEFINE ARRAY_IMMUTABLE_CORE(NAME, TYPE, ACCESSOR_NAME, FORMAT)
159 //%- (void)dealloc {
160 //%  NSAssert(!_autocreator,
161 //%           @"%@: Autocreator must be cleared before release, autocreator: %@",
162 //%           [self class], _autocreator);
163 //%  free(_values);
164 //%  [super dealloc];
165 //%}
166 //%
167 //%- (BOOL)isEqual:(id)other {
168 //%  if (self == other) {
169 //%    return YES;
170 //%  }
171 //%  if (![other isKindOfClass:[GPB##NAME##Array class]]) {
172 //%    return NO;
173 //%  }
174 //%  GPB##NAME##Array *otherArray = other;
175 //%  return (_count == otherArray->_count
176 //%          && memcmp(_values, otherArray->_values, (_count * sizeof(TYPE))) == 0);
177 //%}
178 //%
179 //%- (NSUInteger)hash {
180 //%  // Follow NSArray's lead, and use the count as the hash.
181 //%  return _count;
182 //%}
183 //%
184 //%- (NSString *)description {
185 //%  NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> { ", [self class], self];
186 //%  for (NSUInteger i = 0, count = _count; i < count; ++i) {
187 //%    if (i == 0) {
188 //%      [result appendFormat:@"##FORMAT##", _values[i]];
189 //%    } else {
190 //%      [result appendFormat:@", ##FORMAT##", _values[i]];
191 //%    }
192 //%  }
193 //%  [result appendFormat:@" }"];
194 //%  return result;
195 //%}
196 //%
197 //%- (void)enumerate##ACCESSOR_NAME##ValuesWithBlock:(void (^)(TYPE value, NSUInteger idx, BOOL *stop))block {
198 //%  [self enumerate##ACCESSOR_NAME##ValuesWithOptions:(NSEnumerationOptions)0 usingBlock:block];
199 //%}
200 //%
201 //%- (void)enumerate##ACCESSOR_NAME##ValuesWithOptions:(NSEnumerationOptions)opts
202 //%                  ACCESSOR_NAME$S      usingBlock:(void (^)(TYPE value, NSUInteger idx, BOOL *stop))block {
203 //%  // NSEnumerationConcurrent isn't currently supported (and Apple's docs say that is ok).
204 //%  BOOL stop = NO;
205 //%  if ((opts & NSEnumerationReverse) == 0) {
206 //%    for (NSUInteger i = 0, count = _count; i < count; ++i) {
207 //%      block(_values[i], i, &stop);
208 //%      if (stop) break;
209 //%    }
210 //%  } else if (_count > 0) {
211 //%    for (NSUInteger i = _count; i > 0; --i) {
212 //%      block(_values[i - 1], (i - 1), &stop);
213 //%      if (stop) break;
214 //%    }
215 //%  }
216 //%}
217
218 //%PDDM-DEFINE MUTATION_HOOK_None()
219 //%PDDM-DEFINE MUTATION_METHODS(NAME, TYPE, ACCESSOR_NAME, HOOK_1, HOOK_2)
220 //%- (void)add##ACCESSOR_NAME##Value:(TYPE)value {
221 //%  [self add##ACCESSOR_NAME##Values:&value count:1];
222 //%}
223 //%
224 //%- (void)add##ACCESSOR_NAME##Values:(const TYPE [])values count:(NSUInteger)count {
225 //%  if (values == NULL || count == 0) return;
226 //%MUTATION_HOOK_##HOOK_1()  NSUInteger initialCount = _count;
227 //%  NSUInteger newCount = initialCount + count;
228 //%MAYBE_GROW_TO_SET_COUNT(newCount)
229 //%  memcpy(&_values[initialCount], values, count * sizeof(TYPE));
230 //%  if (_autocreator) {
231 //%    GPBAutocreatedArrayModified(_autocreator, self);
232 //%  }
233 //%}
234 //%
235 //%- (void)insert##ACCESSOR_NAME##Value:(TYPE)value atIndex:(NSUInteger)index {
236 //%VALIDATE_RANGE(index, _count + 1)
237 //%MUTATION_HOOK_##HOOK_2()  NSUInteger initialCount = _count;
238 //%  NSUInteger newCount = initialCount + 1;
239 //%MAYBE_GROW_TO_SET_COUNT(newCount)
240 //%  if (index != initialCount) {
241 //%    memmove(&_values[index + 1], &_values[index], (initialCount - index) * sizeof(TYPE));
242 //%  }
243 //%  _values[index] = value;
244 //%  if (_autocreator) {
245 //%    GPBAutocreatedArrayModified(_autocreator, self);
246 //%  }
247 //%}
248 //%
249 //%- (void)replaceValueAtIndex:(NSUInteger)index with##ACCESSOR_NAME##Value:(TYPE)value {
250 //%VALIDATE_RANGE(index, _count)
251 //%MUTATION_HOOK_##HOOK_2()  _values[index] = value;
252 //%}
253
254 //%PDDM-DEFINE ARRAY_MUTABLE_CORE(NAME, TYPE, ACCESSOR_NAME, FORMAT)
255 //%- (void)internalResizeToCapacity:(NSUInteger)newCapacity {
256 //%  _values = reallocf(_values, newCapacity * sizeof(TYPE));
257 //%  if (_values == NULL) {
258 //%    _capacity = 0;
259 //%    _count = 0;
260 //%    [NSException raise:NSMallocException
261 //%                format:@"Failed to allocate %lu bytes",
262 //%                       (unsigned long)(newCapacity * sizeof(TYPE))];
263 //%  }
264 //%  _capacity = newCapacity;
265 //%}
266 //%
267 //%MUTATION_METHODS(NAME, TYPE, ACCESSOR_NAME, None, None)
268 //%
269 //%- (void)add##ACCESSOR_NAME##ValuesFromArray:(GPB##NAME##Array *)array {
270 //%  [self add##ACCESSOR_NAME##Values:array->_values count:array->_count];
271 //%}
272 //%
273 //%- (void)removeValueAtIndex:(NSUInteger)index {
274 //%VALIDATE_RANGE(index, _count)
275 //%  NSUInteger newCount = _count - 1;
276 //%  if (index != newCount) {
277 //%    memmove(&_values[index], &_values[index + 1], (newCount - index) * sizeof(TYPE));
278 //%  }
279 //%SET_COUNT_AND_MAYBE_SHRINK(newCount)
280 //%}
281 //%
282 //%- (void)removeAll {
283 //%SET_COUNT_AND_MAYBE_SHRINK(0)
284 //%}
285 //%
286 //%- (void)exchangeValueAtIndex:(NSUInteger)idx1
287 //%            withValueAtIndex:(NSUInteger)idx2 {
288 //%VALIDATE_RANGE(idx1, _count)
289 //%VALIDATE_RANGE(idx2, _count)
290 //%  TYPE temp = _values[idx1];
291 //%  _values[idx1] = _values[idx2];
292 //%  _values[idx2] = temp;
293 //%}
294 //%
295
296 //%PDDM-EXPAND ARRAY_INTERFACE_SIMPLE(Int32, int32_t, %d)
297 // This block of code is generated, do not edit it directly.
298
299 #pragma mark - Int32
300
301 @implementation GPBInt32Array {
302  @package
303   int32_t *_values;
304   NSUInteger _count;
305   NSUInteger _capacity;
306 }
307
308 @synthesize count = _count;
309
310 + (instancetype)array {
311   return [[[self alloc] init] autorelease];
312 }
313
314 + (instancetype)arrayWithValue:(int32_t)value {
315   // Cast is needed so the compiler knows what class we are invoking initWithValues: on to get
316   // the type correct.
317   return [[(GPBInt32Array*)[self alloc] initWithValues:&value count:1] autorelease];
318 }
319
320 + (instancetype)arrayWithValueArray:(GPBInt32Array *)array {
321   return [[(GPBInt32Array*)[self alloc] initWithValueArray:array] autorelease];
322 }
323
324 + (instancetype)arrayWithCapacity:(NSUInteger)count {
325   return [[[self alloc] initWithCapacity:count] autorelease];
326 }
327
328 - (instancetype)init {
329   self = [super init];
330   // No work needed;
331   return self;
332 }
333
334 - (instancetype)initWithValueArray:(GPBInt32Array *)array {
335   return [self initWithValues:array->_values count:array->_count];
336 }
337
338 - (instancetype)initWithValues:(const int32_t [])values count:(NSUInteger)count {
339   self = [self init];
340   if (self) {
341     if (count && values) {
342       _values = reallocf(_values, count * sizeof(int32_t));
343       if (_values != NULL) {
344         _capacity = count;
345         memcpy(_values, values, count * sizeof(int32_t));
346         _count = count;
347       } else {
348         [self release];
349         [NSException raise:NSMallocException
350                     format:@"Failed to allocate %lu bytes",
351                            (unsigned long)(count * sizeof(int32_t))];
352       }
353     }
354   }
355   return self;
356 }
357
358 - (instancetype)initWithCapacity:(NSUInteger)count {
359   self = [self initWithValues:NULL count:0];
360   if (self && count) {
361     [self internalResizeToCapacity:count];
362   }
363   return self;
364 }
365
366 - (instancetype)copyWithZone:(NSZone *)zone {
367   return [[GPBInt32Array allocWithZone:zone] initWithValues:_values count:_count];
368 }
369
370 - (void)dealloc {
371   NSAssert(!_autocreator,
372            @"%@: Autocreator must be cleared before release, autocreator: %@",
373            [self class], _autocreator);
374   free(_values);
375   [super dealloc];
376 }
377
378 - (BOOL)isEqual:(id)other {
379   if (self == other) {
380     return YES;
381   }
382   if (![other isKindOfClass:[GPBInt32Array class]]) {
383     return NO;
384   }
385   GPBInt32Array *otherArray = other;
386   return (_count == otherArray->_count
387           && memcmp(_values, otherArray->_values, (_count * sizeof(int32_t))) == 0);
388 }
389
390 - (NSUInteger)hash {
391   // Follow NSArray's lead, and use the count as the hash.
392   return _count;
393 }
394
395 - (NSString *)description {
396   NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> { ", [self class], self];
397   for (NSUInteger i = 0, count = _count; i < count; ++i) {
398     if (i == 0) {
399       [result appendFormat:@"%d", _values[i]];
400     } else {
401       [result appendFormat:@", %d", _values[i]];
402     }
403   }
404   [result appendFormat:@" }"];
405   return result;
406 }
407
408 - (void)enumerateValuesWithBlock:(void (^)(int32_t value, NSUInteger idx, BOOL *stop))block {
409   [self enumerateValuesWithOptions:(NSEnumerationOptions)0 usingBlock:block];
410 }
411
412 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts
413                         usingBlock:(void (^)(int32_t value, NSUInteger idx, BOOL *stop))block {
414   // NSEnumerationConcurrent isn't currently supported (and Apple's docs say that is ok).
415   BOOL stop = NO;
416   if ((opts & NSEnumerationReverse) == 0) {
417     for (NSUInteger i = 0, count = _count; i < count; ++i) {
418       block(_values[i], i, &stop);
419       if (stop) break;
420     }
421   } else if (_count > 0) {
422     for (NSUInteger i = _count; i > 0; --i) {
423       block(_values[i - 1], (i - 1), &stop);
424       if (stop) break;
425     }
426   }
427 }
428
429 - (int32_t)valueAtIndex:(NSUInteger)index {
430   if (index >= _count) {
431     [NSException raise:NSRangeException
432                 format:@"Index (%lu) beyond bounds (%lu)",
433                        (unsigned long)index, (unsigned long)_count];
434   }
435   return _values[index];
436 }
437
438 - (void)internalResizeToCapacity:(NSUInteger)newCapacity {
439   _values = reallocf(_values, newCapacity * sizeof(int32_t));
440   if (_values == NULL) {
441     _capacity = 0;
442     _count = 0;
443     [NSException raise:NSMallocException
444                 format:@"Failed to allocate %lu bytes",
445                        (unsigned long)(newCapacity * sizeof(int32_t))];
446   }
447   _capacity = newCapacity;
448 }
449
450 - (void)addValue:(int32_t)value {
451   [self addValues:&value count:1];
452 }
453
454 - (void)addValues:(const int32_t [])values count:(NSUInteger)count {
455   if (values == NULL || count == 0) return;
456   NSUInteger initialCount = _count;
457   NSUInteger newCount = initialCount + count;
458   if (newCount > _capacity) {
459     [self internalResizeToCapacity:CapacityFromCount(newCount)];
460   }
461   _count = newCount;
462   memcpy(&_values[initialCount], values, count * sizeof(int32_t));
463   if (_autocreator) {
464     GPBAutocreatedArrayModified(_autocreator, self);
465   }
466 }
467
468 - (void)insertValue:(int32_t)value atIndex:(NSUInteger)index {
469   if (index >= _count + 1) {
470     [NSException raise:NSRangeException
471                 format:@"Index (%lu) beyond bounds (%lu)",
472                        (unsigned long)index, (unsigned long)_count + 1];
473   }
474   NSUInteger initialCount = _count;
475   NSUInteger newCount = initialCount + 1;
476   if (newCount > _capacity) {
477     [self internalResizeToCapacity:CapacityFromCount(newCount)];
478   }
479   _count = newCount;
480   if (index != initialCount) {
481     memmove(&_values[index + 1], &_values[index], (initialCount - index) * sizeof(int32_t));
482   }
483   _values[index] = value;
484   if (_autocreator) {
485     GPBAutocreatedArrayModified(_autocreator, self);
486   }
487 }
488
489 - (void)replaceValueAtIndex:(NSUInteger)index withValue:(int32_t)value {
490   if (index >= _count) {
491     [NSException raise:NSRangeException
492                 format:@"Index (%lu) beyond bounds (%lu)",
493                        (unsigned long)index, (unsigned long)_count];
494   }
495   _values[index] = value;
496 }
497
498 - (void)addValuesFromArray:(GPBInt32Array *)array {
499   [self addValues:array->_values count:array->_count];
500 }
501
502 - (void)removeValueAtIndex:(NSUInteger)index {
503   if (index >= _count) {
504     [NSException raise:NSRangeException
505                 format:@"Index (%lu) beyond bounds (%lu)",
506                        (unsigned long)index, (unsigned long)_count];
507   }
508   NSUInteger newCount = _count - 1;
509   if (index != newCount) {
510     memmove(&_values[index], &_values[index + 1], (newCount - index) * sizeof(int32_t));
511   }
512   _count = newCount;
513   if ((newCount + (2 * kChunkSize)) < _capacity) {
514     [self internalResizeToCapacity:CapacityFromCount(newCount)];
515   }
516 }
517
518 - (void)removeAll {
519   _count = 0;
520   if ((0 + (2 * kChunkSize)) < _capacity) {
521     [self internalResizeToCapacity:CapacityFromCount(0)];
522   }
523 }
524
525 - (void)exchangeValueAtIndex:(NSUInteger)idx1
526             withValueAtIndex:(NSUInteger)idx2 {
527   if (idx1 >= _count) {
528     [NSException raise:NSRangeException
529                 format:@"Index (%lu) beyond bounds (%lu)",
530                        (unsigned long)idx1, (unsigned long)_count];
531   }
532   if (idx2 >= _count) {
533     [NSException raise:NSRangeException
534                 format:@"Index (%lu) beyond bounds (%lu)",
535                        (unsigned long)idx2, (unsigned long)_count];
536   }
537   int32_t temp = _values[idx1];
538   _values[idx1] = _values[idx2];
539   _values[idx2] = temp;
540 }
541
542 @end
543
544 //%PDDM-EXPAND ARRAY_INTERFACE_SIMPLE(UInt32, uint32_t, %u)
545 // This block of code is generated, do not edit it directly.
546
547 #pragma mark - UInt32
548
549 @implementation GPBUInt32Array {
550  @package
551   uint32_t *_values;
552   NSUInteger _count;
553   NSUInteger _capacity;
554 }
555
556 @synthesize count = _count;
557
558 + (instancetype)array {
559   return [[[self alloc] init] autorelease];
560 }
561
562 + (instancetype)arrayWithValue:(uint32_t)value {
563   // Cast is needed so the compiler knows what class we are invoking initWithValues: on to get
564   // the type correct.
565   return [[(GPBUInt32Array*)[self alloc] initWithValues:&value count:1] autorelease];
566 }
567
568 + (instancetype)arrayWithValueArray:(GPBUInt32Array *)array {
569   return [[(GPBUInt32Array*)[self alloc] initWithValueArray:array] autorelease];
570 }
571
572 + (instancetype)arrayWithCapacity:(NSUInteger)count {
573   return [[[self alloc] initWithCapacity:count] autorelease];
574 }
575
576 - (instancetype)init {
577   self = [super init];
578   // No work needed;
579   return self;
580 }
581
582 - (instancetype)initWithValueArray:(GPBUInt32Array *)array {
583   return [self initWithValues:array->_values count:array->_count];
584 }
585
586 - (instancetype)initWithValues:(const uint32_t [])values count:(NSUInteger)count {
587   self = [self init];
588   if (self) {
589     if (count && values) {
590       _values = reallocf(_values, count * sizeof(uint32_t));
591       if (_values != NULL) {
592         _capacity = count;
593         memcpy(_values, values, count * sizeof(uint32_t));
594         _count = count;
595       } else {
596         [self release];
597         [NSException raise:NSMallocException
598                     format:@"Failed to allocate %lu bytes",
599                            (unsigned long)(count * sizeof(uint32_t))];
600       }
601     }
602   }
603   return self;
604 }
605
606 - (instancetype)initWithCapacity:(NSUInteger)count {
607   self = [self initWithValues:NULL count:0];
608   if (self && count) {
609     [self internalResizeToCapacity:count];
610   }
611   return self;
612 }
613
614 - (instancetype)copyWithZone:(NSZone *)zone {
615   return [[GPBUInt32Array allocWithZone:zone] initWithValues:_values count:_count];
616 }
617
618 - (void)dealloc {
619   NSAssert(!_autocreator,
620            @"%@: Autocreator must be cleared before release, autocreator: %@",
621            [self class], _autocreator);
622   free(_values);
623   [super dealloc];
624 }
625
626 - (BOOL)isEqual:(id)other {
627   if (self == other) {
628     return YES;
629   }
630   if (![other isKindOfClass:[GPBUInt32Array class]]) {
631     return NO;
632   }
633   GPBUInt32Array *otherArray = other;
634   return (_count == otherArray->_count
635           && memcmp(_values, otherArray->_values, (_count * sizeof(uint32_t))) == 0);
636 }
637
638 - (NSUInteger)hash {
639   // Follow NSArray's lead, and use the count as the hash.
640   return _count;
641 }
642
643 - (NSString *)description {
644   NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> { ", [self class], self];
645   for (NSUInteger i = 0, count = _count; i < count; ++i) {
646     if (i == 0) {
647       [result appendFormat:@"%u", _values[i]];
648     } else {
649       [result appendFormat:@", %u", _values[i]];
650     }
651   }
652   [result appendFormat:@" }"];
653   return result;
654 }
655
656 - (void)enumerateValuesWithBlock:(void (^)(uint32_t value, NSUInteger idx, BOOL *stop))block {
657   [self enumerateValuesWithOptions:(NSEnumerationOptions)0 usingBlock:block];
658 }
659
660 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts
661                         usingBlock:(void (^)(uint32_t value, NSUInteger idx, BOOL *stop))block {
662   // NSEnumerationConcurrent isn't currently supported (and Apple's docs say that is ok).
663   BOOL stop = NO;
664   if ((opts & NSEnumerationReverse) == 0) {
665     for (NSUInteger i = 0, count = _count; i < count; ++i) {
666       block(_values[i], i, &stop);
667       if (stop) break;
668     }
669   } else if (_count > 0) {
670     for (NSUInteger i = _count; i > 0; --i) {
671       block(_values[i - 1], (i - 1), &stop);
672       if (stop) break;
673     }
674   }
675 }
676
677 - (uint32_t)valueAtIndex:(NSUInteger)index {
678   if (index >= _count) {
679     [NSException raise:NSRangeException
680                 format:@"Index (%lu) beyond bounds (%lu)",
681                        (unsigned long)index, (unsigned long)_count];
682   }
683   return _values[index];
684 }
685
686 - (void)internalResizeToCapacity:(NSUInteger)newCapacity {
687   _values = reallocf(_values, newCapacity * sizeof(uint32_t));
688   if (_values == NULL) {
689     _capacity = 0;
690     _count = 0;
691     [NSException raise:NSMallocException
692                 format:@"Failed to allocate %lu bytes",
693                        (unsigned long)(newCapacity * sizeof(uint32_t))];
694   }
695   _capacity = newCapacity;
696 }
697
698 - (void)addValue:(uint32_t)value {
699   [self addValues:&value count:1];
700 }
701
702 - (void)addValues:(const uint32_t [])values count:(NSUInteger)count {
703   if (values == NULL || count == 0) return;
704   NSUInteger initialCount = _count;
705   NSUInteger newCount = initialCount + count;
706   if (newCount > _capacity) {
707     [self internalResizeToCapacity:CapacityFromCount(newCount)];
708   }
709   _count = newCount;
710   memcpy(&_values[initialCount], values, count * sizeof(uint32_t));
711   if (_autocreator) {
712     GPBAutocreatedArrayModified(_autocreator, self);
713   }
714 }
715
716 - (void)insertValue:(uint32_t)value atIndex:(NSUInteger)index {
717   if (index >= _count + 1) {
718     [NSException raise:NSRangeException
719                 format:@"Index (%lu) beyond bounds (%lu)",
720                        (unsigned long)index, (unsigned long)_count + 1];
721   }
722   NSUInteger initialCount = _count;
723   NSUInteger newCount = initialCount + 1;
724   if (newCount > _capacity) {
725     [self internalResizeToCapacity:CapacityFromCount(newCount)];
726   }
727   _count = newCount;
728   if (index != initialCount) {
729     memmove(&_values[index + 1], &_values[index], (initialCount - index) * sizeof(uint32_t));
730   }
731   _values[index] = value;
732   if (_autocreator) {
733     GPBAutocreatedArrayModified(_autocreator, self);
734   }
735 }
736
737 - (void)replaceValueAtIndex:(NSUInteger)index withValue:(uint32_t)value {
738   if (index >= _count) {
739     [NSException raise:NSRangeException
740                 format:@"Index (%lu) beyond bounds (%lu)",
741                        (unsigned long)index, (unsigned long)_count];
742   }
743   _values[index] = value;
744 }
745
746 - (void)addValuesFromArray:(GPBUInt32Array *)array {
747   [self addValues:array->_values count:array->_count];
748 }
749
750 - (void)removeValueAtIndex:(NSUInteger)index {
751   if (index >= _count) {
752     [NSException raise:NSRangeException
753                 format:@"Index (%lu) beyond bounds (%lu)",
754                        (unsigned long)index, (unsigned long)_count];
755   }
756   NSUInteger newCount = _count - 1;
757   if (index != newCount) {
758     memmove(&_values[index], &_values[index + 1], (newCount - index) * sizeof(uint32_t));
759   }
760   _count = newCount;
761   if ((newCount + (2 * kChunkSize)) < _capacity) {
762     [self internalResizeToCapacity:CapacityFromCount(newCount)];
763   }
764 }
765
766 - (void)removeAll {
767   _count = 0;
768   if ((0 + (2 * kChunkSize)) < _capacity) {
769     [self internalResizeToCapacity:CapacityFromCount(0)];
770   }
771 }
772
773 - (void)exchangeValueAtIndex:(NSUInteger)idx1
774             withValueAtIndex:(NSUInteger)idx2 {
775   if (idx1 >= _count) {
776     [NSException raise:NSRangeException
777                 format:@"Index (%lu) beyond bounds (%lu)",
778                        (unsigned long)idx1, (unsigned long)_count];
779   }
780   if (idx2 >= _count) {
781     [NSException raise:NSRangeException
782                 format:@"Index (%lu) beyond bounds (%lu)",
783                        (unsigned long)idx2, (unsigned long)_count];
784   }
785   uint32_t temp = _values[idx1];
786   _values[idx1] = _values[idx2];
787   _values[idx2] = temp;
788 }
789
790 @end
791
792 //%PDDM-EXPAND ARRAY_INTERFACE_SIMPLE(Int64, int64_t, %lld)
793 // This block of code is generated, do not edit it directly.
794
795 #pragma mark - Int64
796
797 @implementation GPBInt64Array {
798  @package
799   int64_t *_values;
800   NSUInteger _count;
801   NSUInteger _capacity;
802 }
803
804 @synthesize count = _count;
805
806 + (instancetype)array {
807   return [[[self alloc] init] autorelease];
808 }
809
810 + (instancetype)arrayWithValue:(int64_t)value {
811   // Cast is needed so the compiler knows what class we are invoking initWithValues: on to get
812   // the type correct.
813   return [[(GPBInt64Array*)[self alloc] initWithValues:&value count:1] autorelease];
814 }
815
816 + (instancetype)arrayWithValueArray:(GPBInt64Array *)array {
817   return [[(GPBInt64Array*)[self alloc] initWithValueArray:array] autorelease];
818 }
819
820 + (instancetype)arrayWithCapacity:(NSUInteger)count {
821   return [[[self alloc] initWithCapacity:count] autorelease];
822 }
823
824 - (instancetype)init {
825   self = [super init];
826   // No work needed;
827   return self;
828 }
829
830 - (instancetype)initWithValueArray:(GPBInt64Array *)array {
831   return [self initWithValues:array->_values count:array->_count];
832 }
833
834 - (instancetype)initWithValues:(const int64_t [])values count:(NSUInteger)count {
835   self = [self init];
836   if (self) {
837     if (count && values) {
838       _values = reallocf(_values, count * sizeof(int64_t));
839       if (_values != NULL) {
840         _capacity = count;
841         memcpy(_values, values, count * sizeof(int64_t));
842         _count = count;
843       } else {
844         [self release];
845         [NSException raise:NSMallocException
846                     format:@"Failed to allocate %lu bytes",
847                            (unsigned long)(count * sizeof(int64_t))];
848       }
849     }
850   }
851   return self;
852 }
853
854 - (instancetype)initWithCapacity:(NSUInteger)count {
855   self = [self initWithValues:NULL count:0];
856   if (self && count) {
857     [self internalResizeToCapacity:count];
858   }
859   return self;
860 }
861
862 - (instancetype)copyWithZone:(NSZone *)zone {
863   return [[GPBInt64Array allocWithZone:zone] initWithValues:_values count:_count];
864 }
865
866 - (void)dealloc {
867   NSAssert(!_autocreator,
868            @"%@: Autocreator must be cleared before release, autocreator: %@",
869            [self class], _autocreator);
870   free(_values);
871   [super dealloc];
872 }
873
874 - (BOOL)isEqual:(id)other {
875   if (self == other) {
876     return YES;
877   }
878   if (![other isKindOfClass:[GPBInt64Array class]]) {
879     return NO;
880   }
881   GPBInt64Array *otherArray = other;
882   return (_count == otherArray->_count
883           && memcmp(_values, otherArray->_values, (_count * sizeof(int64_t))) == 0);
884 }
885
886 - (NSUInteger)hash {
887   // Follow NSArray's lead, and use the count as the hash.
888   return _count;
889 }
890
891 - (NSString *)description {
892   NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> { ", [self class], self];
893   for (NSUInteger i = 0, count = _count; i < count; ++i) {
894     if (i == 0) {
895       [result appendFormat:@"%lld", _values[i]];
896     } else {
897       [result appendFormat:@", %lld", _values[i]];
898     }
899   }
900   [result appendFormat:@" }"];
901   return result;
902 }
903
904 - (void)enumerateValuesWithBlock:(void (^)(int64_t value, NSUInteger idx, BOOL *stop))block {
905   [self enumerateValuesWithOptions:(NSEnumerationOptions)0 usingBlock:block];
906 }
907
908 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts
909                         usingBlock:(void (^)(int64_t value, NSUInteger idx, BOOL *stop))block {
910   // NSEnumerationConcurrent isn't currently supported (and Apple's docs say that is ok).
911   BOOL stop = NO;
912   if ((opts & NSEnumerationReverse) == 0) {
913     for (NSUInteger i = 0, count = _count; i < count; ++i) {
914       block(_values[i], i, &stop);
915       if (stop) break;
916     }
917   } else if (_count > 0) {
918     for (NSUInteger i = _count; i > 0; --i) {
919       block(_values[i - 1], (i - 1), &stop);
920       if (stop) break;
921     }
922   }
923 }
924
925 - (int64_t)valueAtIndex:(NSUInteger)index {
926   if (index >= _count) {
927     [NSException raise:NSRangeException
928                 format:@"Index (%lu) beyond bounds (%lu)",
929                        (unsigned long)index, (unsigned long)_count];
930   }
931   return _values[index];
932 }
933
934 - (void)internalResizeToCapacity:(NSUInteger)newCapacity {
935   _values = reallocf(_values, newCapacity * sizeof(int64_t));
936   if (_values == NULL) {
937     _capacity = 0;
938     _count = 0;
939     [NSException raise:NSMallocException
940                 format:@"Failed to allocate %lu bytes",
941                        (unsigned long)(newCapacity * sizeof(int64_t))];
942   }
943   _capacity = newCapacity;
944 }
945
946 - (void)addValue:(int64_t)value {
947   [self addValues:&value count:1];
948 }
949
950 - (void)addValues:(const int64_t [])values count:(NSUInteger)count {
951   if (values == NULL || count == 0) return;
952   NSUInteger initialCount = _count;
953   NSUInteger newCount = initialCount + count;
954   if (newCount > _capacity) {
955     [self internalResizeToCapacity:CapacityFromCount(newCount)];
956   }
957   _count = newCount;
958   memcpy(&_values[initialCount], values, count * sizeof(int64_t));
959   if (_autocreator) {
960     GPBAutocreatedArrayModified(_autocreator, self);
961   }
962 }
963
964 - (void)insertValue:(int64_t)value atIndex:(NSUInteger)index {
965   if (index >= _count + 1) {
966     [NSException raise:NSRangeException
967                 format:@"Index (%lu) beyond bounds (%lu)",
968                        (unsigned long)index, (unsigned long)_count + 1];
969   }
970   NSUInteger initialCount = _count;
971   NSUInteger newCount = initialCount + 1;
972   if (newCount > _capacity) {
973     [self internalResizeToCapacity:CapacityFromCount(newCount)];
974   }
975   _count = newCount;
976   if (index != initialCount) {
977     memmove(&_values[index + 1], &_values[index], (initialCount - index) * sizeof(int64_t));
978   }
979   _values[index] = value;
980   if (_autocreator) {
981     GPBAutocreatedArrayModified(_autocreator, self);
982   }
983 }
984
985 - (void)replaceValueAtIndex:(NSUInteger)index withValue:(int64_t)value {
986   if (index >= _count) {
987     [NSException raise:NSRangeException
988                 format:@"Index (%lu) beyond bounds (%lu)",
989                        (unsigned long)index, (unsigned long)_count];
990   }
991   _values[index] = value;
992 }
993
994 - (void)addValuesFromArray:(GPBInt64Array *)array {
995   [self addValues:array->_values count:array->_count];
996 }
997
998 - (void)removeValueAtIndex:(NSUInteger)index {
999   if (index >= _count) {
1000     [NSException raise:NSRangeException
1001                 format:@"Index (%lu) beyond bounds (%lu)",
1002                        (unsigned long)index, (unsigned long)_count];
1003   }
1004   NSUInteger newCount = _count - 1;
1005   if (index != newCount) {
1006     memmove(&_values[index], &_values[index + 1], (newCount - index) * sizeof(int64_t));
1007   }
1008   _count = newCount;
1009   if ((newCount + (2 * kChunkSize)) < _capacity) {
1010     [self internalResizeToCapacity:CapacityFromCount(newCount)];
1011   }
1012 }
1013
1014 - (void)removeAll {
1015   _count = 0;
1016   if ((0 + (2 * kChunkSize)) < _capacity) {
1017     [self internalResizeToCapacity:CapacityFromCount(0)];
1018   }
1019 }
1020
1021 - (void)exchangeValueAtIndex:(NSUInteger)idx1
1022             withValueAtIndex:(NSUInteger)idx2 {
1023   if (idx1 >= _count) {
1024     [NSException raise:NSRangeException
1025                 format:@"Index (%lu) beyond bounds (%lu)",
1026                        (unsigned long)idx1, (unsigned long)_count];
1027   }
1028   if (idx2 >= _count) {
1029     [NSException raise:NSRangeException
1030                 format:@"Index (%lu) beyond bounds (%lu)",
1031                        (unsigned long)idx2, (unsigned long)_count];
1032   }
1033   int64_t temp = _values[idx1];
1034   _values[idx1] = _values[idx2];
1035   _values[idx2] = temp;
1036 }
1037
1038 @end
1039
1040 //%PDDM-EXPAND ARRAY_INTERFACE_SIMPLE(UInt64, uint64_t, %llu)
1041 // This block of code is generated, do not edit it directly.
1042
1043 #pragma mark - UInt64
1044
1045 @implementation GPBUInt64Array {
1046  @package
1047   uint64_t *_values;
1048   NSUInteger _count;
1049   NSUInteger _capacity;
1050 }
1051
1052 @synthesize count = _count;
1053
1054 + (instancetype)array {
1055   return [[[self alloc] init] autorelease];
1056 }
1057
1058 + (instancetype)arrayWithValue:(uint64_t)value {
1059   // Cast is needed so the compiler knows what class we are invoking initWithValues: on to get
1060   // the type correct.
1061   return [[(GPBUInt64Array*)[self alloc] initWithValues:&value count:1] autorelease];
1062 }
1063
1064 + (instancetype)arrayWithValueArray:(GPBUInt64Array *)array {
1065   return [[(GPBUInt64Array*)[self alloc] initWithValueArray:array] autorelease];
1066 }
1067
1068 + (instancetype)arrayWithCapacity:(NSUInteger)count {
1069   return [[[self alloc] initWithCapacity:count] autorelease];
1070 }
1071
1072 - (instancetype)init {
1073   self = [super init];
1074   // No work needed;
1075   return self;
1076 }
1077
1078 - (instancetype)initWithValueArray:(GPBUInt64Array *)array {
1079   return [self initWithValues:array->_values count:array->_count];
1080 }
1081
1082 - (instancetype)initWithValues:(const uint64_t [])values count:(NSUInteger)count {
1083   self = [self init];
1084   if (self) {
1085     if (count && values) {
1086       _values = reallocf(_values, count * sizeof(uint64_t));
1087       if (_values != NULL) {
1088         _capacity = count;
1089         memcpy(_values, values, count * sizeof(uint64_t));
1090         _count = count;
1091       } else {
1092         [self release];
1093         [NSException raise:NSMallocException
1094                     format:@"Failed to allocate %lu bytes",
1095                            (unsigned long)(count * sizeof(uint64_t))];
1096       }
1097     }
1098   }
1099   return self;
1100 }
1101
1102 - (instancetype)initWithCapacity:(NSUInteger)count {
1103   self = [self initWithValues:NULL count:0];
1104   if (self && count) {
1105     [self internalResizeToCapacity:count];
1106   }
1107   return self;
1108 }
1109
1110 - (instancetype)copyWithZone:(NSZone *)zone {
1111   return [[GPBUInt64Array allocWithZone:zone] initWithValues:_values count:_count];
1112 }
1113
1114 - (void)dealloc {
1115   NSAssert(!_autocreator,
1116            @"%@: Autocreator must be cleared before release, autocreator: %@",
1117            [self class], _autocreator);
1118   free(_values);
1119   [super dealloc];
1120 }
1121
1122 - (BOOL)isEqual:(id)other {
1123   if (self == other) {
1124     return YES;
1125   }
1126   if (![other isKindOfClass:[GPBUInt64Array class]]) {
1127     return NO;
1128   }
1129   GPBUInt64Array *otherArray = other;
1130   return (_count == otherArray->_count
1131           && memcmp(_values, otherArray->_values, (_count * sizeof(uint64_t))) == 0);
1132 }
1133
1134 - (NSUInteger)hash {
1135   // Follow NSArray's lead, and use the count as the hash.
1136   return _count;
1137 }
1138
1139 - (NSString *)description {
1140   NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> { ", [self class], self];
1141   for (NSUInteger i = 0, count = _count; i < count; ++i) {
1142     if (i == 0) {
1143       [result appendFormat:@"%llu", _values[i]];
1144     } else {
1145       [result appendFormat:@", %llu", _values[i]];
1146     }
1147   }
1148   [result appendFormat:@" }"];
1149   return result;
1150 }
1151
1152 - (void)enumerateValuesWithBlock:(void (^)(uint64_t value, NSUInteger idx, BOOL *stop))block {
1153   [self enumerateValuesWithOptions:(NSEnumerationOptions)0 usingBlock:block];
1154 }
1155
1156 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts
1157                         usingBlock:(void (^)(uint64_t value, NSUInteger idx, BOOL *stop))block {
1158   // NSEnumerationConcurrent isn't currently supported (and Apple's docs say that is ok).
1159   BOOL stop = NO;
1160   if ((opts & NSEnumerationReverse) == 0) {
1161     for (NSUInteger i = 0, count = _count; i < count; ++i) {
1162       block(_values[i], i, &stop);
1163       if (stop) break;
1164     }
1165   } else if (_count > 0) {
1166     for (NSUInteger i = _count; i > 0; --i) {
1167       block(_values[i - 1], (i - 1), &stop);
1168       if (stop) break;
1169     }
1170   }
1171 }
1172
1173 - (uint64_t)valueAtIndex:(NSUInteger)index {
1174   if (index >= _count) {
1175     [NSException raise:NSRangeException
1176                 format:@"Index (%lu) beyond bounds (%lu)",
1177                        (unsigned long)index, (unsigned long)_count];
1178   }
1179   return _values[index];
1180 }
1181
1182 - (void)internalResizeToCapacity:(NSUInteger)newCapacity {
1183   _values = reallocf(_values, newCapacity * sizeof(uint64_t));
1184   if (_values == NULL) {
1185     _capacity = 0;
1186     _count = 0;
1187     [NSException raise:NSMallocException
1188                 format:@"Failed to allocate %lu bytes",
1189                        (unsigned long)(newCapacity * sizeof(uint64_t))];
1190   }
1191   _capacity = newCapacity;
1192 }
1193
1194 - (void)addValue:(uint64_t)value {
1195   [self addValues:&value count:1];
1196 }
1197
1198 - (void)addValues:(const uint64_t [])values count:(NSUInteger)count {
1199   if (values == NULL || count == 0) return;
1200   NSUInteger initialCount = _count;
1201   NSUInteger newCount = initialCount + count;
1202   if (newCount > _capacity) {
1203     [self internalResizeToCapacity:CapacityFromCount(newCount)];
1204   }
1205   _count = newCount;
1206   memcpy(&_values[initialCount], values, count * sizeof(uint64_t));
1207   if (_autocreator) {
1208     GPBAutocreatedArrayModified(_autocreator, self);
1209   }
1210 }
1211
1212 - (void)insertValue:(uint64_t)value atIndex:(NSUInteger)index {
1213   if (index >= _count + 1) {
1214     [NSException raise:NSRangeException
1215                 format:@"Index (%lu) beyond bounds (%lu)",
1216                        (unsigned long)index, (unsigned long)_count + 1];
1217   }
1218   NSUInteger initialCount = _count;
1219   NSUInteger newCount = initialCount + 1;
1220   if (newCount > _capacity) {
1221     [self internalResizeToCapacity:CapacityFromCount(newCount)];
1222   }
1223   _count = newCount;
1224   if (index != initialCount) {
1225     memmove(&_values[index + 1], &_values[index], (initialCount - index) * sizeof(uint64_t));
1226   }
1227   _values[index] = value;
1228   if (_autocreator) {
1229     GPBAutocreatedArrayModified(_autocreator, self);
1230   }
1231 }
1232
1233 - (void)replaceValueAtIndex:(NSUInteger)index withValue:(uint64_t)value {
1234   if (index >= _count) {
1235     [NSException raise:NSRangeException
1236                 format:@"Index (%lu) beyond bounds (%lu)",
1237                        (unsigned long)index, (unsigned long)_count];
1238   }
1239   _values[index] = value;
1240 }
1241
1242 - (void)addValuesFromArray:(GPBUInt64Array *)array {
1243   [self addValues:array->_values count:array->_count];
1244 }
1245
1246 - (void)removeValueAtIndex:(NSUInteger)index {
1247   if (index >= _count) {
1248     [NSException raise:NSRangeException
1249                 format:@"Index (%lu) beyond bounds (%lu)",
1250                        (unsigned long)index, (unsigned long)_count];
1251   }
1252   NSUInteger newCount = _count - 1;
1253   if (index != newCount) {
1254     memmove(&_values[index], &_values[index + 1], (newCount - index) * sizeof(uint64_t));
1255   }
1256   _count = newCount;
1257   if ((newCount + (2 * kChunkSize)) < _capacity) {
1258     [self internalResizeToCapacity:CapacityFromCount(newCount)];
1259   }
1260 }
1261
1262 - (void)removeAll {
1263   _count = 0;
1264   if ((0 + (2 * kChunkSize)) < _capacity) {
1265     [self internalResizeToCapacity:CapacityFromCount(0)];
1266   }
1267 }
1268
1269 - (void)exchangeValueAtIndex:(NSUInteger)idx1
1270             withValueAtIndex:(NSUInteger)idx2 {
1271   if (idx1 >= _count) {
1272     [NSException raise:NSRangeException
1273                 format:@"Index (%lu) beyond bounds (%lu)",
1274                        (unsigned long)idx1, (unsigned long)_count];
1275   }
1276   if (idx2 >= _count) {
1277     [NSException raise:NSRangeException
1278                 format:@"Index (%lu) beyond bounds (%lu)",
1279                        (unsigned long)idx2, (unsigned long)_count];
1280   }
1281   uint64_t temp = _values[idx1];
1282   _values[idx1] = _values[idx2];
1283   _values[idx2] = temp;
1284 }
1285
1286 @end
1287
1288 //%PDDM-EXPAND ARRAY_INTERFACE_SIMPLE(Float, float, %f)
1289 // This block of code is generated, do not edit it directly.
1290
1291 #pragma mark - Float
1292
1293 @implementation GPBFloatArray {
1294  @package
1295   float *_values;
1296   NSUInteger _count;
1297   NSUInteger _capacity;
1298 }
1299
1300 @synthesize count = _count;
1301
1302 + (instancetype)array {
1303   return [[[self alloc] init] autorelease];
1304 }
1305
1306 + (instancetype)arrayWithValue:(float)value {
1307   // Cast is needed so the compiler knows what class we are invoking initWithValues: on to get
1308   // the type correct.
1309   return [[(GPBFloatArray*)[self alloc] initWithValues:&value count:1] autorelease];
1310 }
1311
1312 + (instancetype)arrayWithValueArray:(GPBFloatArray *)array {
1313   return [[(GPBFloatArray*)[self alloc] initWithValueArray:array] autorelease];
1314 }
1315
1316 + (instancetype)arrayWithCapacity:(NSUInteger)count {
1317   return [[[self alloc] initWithCapacity:count] autorelease];
1318 }
1319
1320 - (instancetype)init {
1321   self = [super init];
1322   // No work needed;
1323   return self;
1324 }
1325
1326 - (instancetype)initWithValueArray:(GPBFloatArray *)array {
1327   return [self initWithValues:array->_values count:array->_count];
1328 }
1329
1330 - (instancetype)initWithValues:(const float [])values count:(NSUInteger)count {
1331   self = [self init];
1332   if (self) {
1333     if (count && values) {
1334       _values = reallocf(_values, count * sizeof(float));
1335       if (_values != NULL) {
1336         _capacity = count;
1337         memcpy(_values, values, count * sizeof(float));
1338         _count = count;
1339       } else {
1340         [self release];
1341         [NSException raise:NSMallocException
1342                     format:@"Failed to allocate %lu bytes",
1343                            (unsigned long)(count * sizeof(float))];
1344       }
1345     }
1346   }
1347   return self;
1348 }
1349
1350 - (instancetype)initWithCapacity:(NSUInteger)count {
1351   self = [self initWithValues:NULL count:0];
1352   if (self && count) {
1353     [self internalResizeToCapacity:count];
1354   }
1355   return self;
1356 }
1357
1358 - (instancetype)copyWithZone:(NSZone *)zone {
1359   return [[GPBFloatArray allocWithZone:zone] initWithValues:_values count:_count];
1360 }
1361
1362 - (void)dealloc {
1363   NSAssert(!_autocreator,
1364            @"%@: Autocreator must be cleared before release, autocreator: %@",
1365            [self class], _autocreator);
1366   free(_values);
1367   [super dealloc];
1368 }
1369
1370 - (BOOL)isEqual:(id)other {
1371   if (self == other) {
1372     return YES;
1373   }
1374   if (![other isKindOfClass:[GPBFloatArray class]]) {
1375     return NO;
1376   }
1377   GPBFloatArray *otherArray = other;
1378   return (_count == otherArray->_count
1379           && memcmp(_values, otherArray->_values, (_count * sizeof(float))) == 0);
1380 }
1381
1382 - (NSUInteger)hash {
1383   // Follow NSArray's lead, and use the count as the hash.
1384   return _count;
1385 }
1386
1387 - (NSString *)description {
1388   NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> { ", [self class], self];
1389   for (NSUInteger i = 0, count = _count; i < count; ++i) {
1390     if (i == 0) {
1391       [result appendFormat:@"%f", _values[i]];
1392     } else {
1393       [result appendFormat:@", %f", _values[i]];
1394     }
1395   }
1396   [result appendFormat:@" }"];
1397   return result;
1398 }
1399
1400 - (void)enumerateValuesWithBlock:(void (^)(float value, NSUInteger idx, BOOL *stop))block {
1401   [self enumerateValuesWithOptions:(NSEnumerationOptions)0 usingBlock:block];
1402 }
1403
1404 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts
1405                         usingBlock:(void (^)(float value, NSUInteger idx, BOOL *stop))block {
1406   // NSEnumerationConcurrent isn't currently supported (and Apple's docs say that is ok).
1407   BOOL stop = NO;
1408   if ((opts & NSEnumerationReverse) == 0) {
1409     for (NSUInteger i = 0, count = _count; i < count; ++i) {
1410       block(_values[i], i, &stop);
1411       if (stop) break;
1412     }
1413   } else if (_count > 0) {
1414     for (NSUInteger i = _count; i > 0; --i) {
1415       block(_values[i - 1], (i - 1), &stop);
1416       if (stop) break;
1417     }
1418   }
1419 }
1420
1421 - (float)valueAtIndex:(NSUInteger)index {
1422   if (index >= _count) {
1423     [NSException raise:NSRangeException
1424                 format:@"Index (%lu) beyond bounds (%lu)",
1425                        (unsigned long)index, (unsigned long)_count];
1426   }
1427   return _values[index];
1428 }
1429
1430 - (void)internalResizeToCapacity:(NSUInteger)newCapacity {
1431   _values = reallocf(_values, newCapacity * sizeof(float));
1432   if (_values == NULL) {
1433     _capacity = 0;
1434     _count = 0;
1435     [NSException raise:NSMallocException
1436                 format:@"Failed to allocate %lu bytes",
1437                        (unsigned long)(newCapacity * sizeof(float))];
1438   }
1439   _capacity = newCapacity;
1440 }
1441
1442 - (void)addValue:(float)value {
1443   [self addValues:&value count:1];
1444 }
1445
1446 - (void)addValues:(const float [])values count:(NSUInteger)count {
1447   if (values == NULL || count == 0) return;
1448   NSUInteger initialCount = _count;
1449   NSUInteger newCount = initialCount + count;
1450   if (newCount > _capacity) {
1451     [self internalResizeToCapacity:CapacityFromCount(newCount)];
1452   }
1453   _count = newCount;
1454   memcpy(&_values[initialCount], values, count * sizeof(float));
1455   if (_autocreator) {
1456     GPBAutocreatedArrayModified(_autocreator, self);
1457   }
1458 }
1459
1460 - (void)insertValue:(float)value atIndex:(NSUInteger)index {
1461   if (index >= _count + 1) {
1462     [NSException raise:NSRangeException
1463                 format:@"Index (%lu) beyond bounds (%lu)",
1464                        (unsigned long)index, (unsigned long)_count + 1];
1465   }
1466   NSUInteger initialCount = _count;
1467   NSUInteger newCount = initialCount + 1;
1468   if (newCount > _capacity) {
1469     [self internalResizeToCapacity:CapacityFromCount(newCount)];
1470   }
1471   _count = newCount;
1472   if (index != initialCount) {
1473     memmove(&_values[index + 1], &_values[index], (initialCount - index) * sizeof(float));
1474   }
1475   _values[index] = value;
1476   if (_autocreator) {
1477     GPBAutocreatedArrayModified(_autocreator, self);
1478   }
1479 }
1480
1481 - (void)replaceValueAtIndex:(NSUInteger)index withValue:(float)value {
1482   if (index >= _count) {
1483     [NSException raise:NSRangeException
1484                 format:@"Index (%lu) beyond bounds (%lu)",
1485                        (unsigned long)index, (unsigned long)_count];
1486   }
1487   _values[index] = value;
1488 }
1489
1490 - (void)addValuesFromArray:(GPBFloatArray *)array {
1491   [self addValues:array->_values count:array->_count];
1492 }
1493
1494 - (void)removeValueAtIndex:(NSUInteger)index {
1495   if (index >= _count) {
1496     [NSException raise:NSRangeException
1497                 format:@"Index (%lu) beyond bounds (%lu)",
1498                        (unsigned long)index, (unsigned long)_count];
1499   }
1500   NSUInteger newCount = _count - 1;
1501   if (index != newCount) {
1502     memmove(&_values[index], &_values[index + 1], (newCount - index) * sizeof(float));
1503   }
1504   _count = newCount;
1505   if ((newCount + (2 * kChunkSize)) < _capacity) {
1506     [self internalResizeToCapacity:CapacityFromCount(newCount)];
1507   }
1508 }
1509
1510 - (void)removeAll {
1511   _count = 0;
1512   if ((0 + (2 * kChunkSize)) < _capacity) {
1513     [self internalResizeToCapacity:CapacityFromCount(0)];
1514   }
1515 }
1516
1517 - (void)exchangeValueAtIndex:(NSUInteger)idx1
1518             withValueAtIndex:(NSUInteger)idx2 {
1519   if (idx1 >= _count) {
1520     [NSException raise:NSRangeException
1521                 format:@"Index (%lu) beyond bounds (%lu)",
1522                        (unsigned long)idx1, (unsigned long)_count];
1523   }
1524   if (idx2 >= _count) {
1525     [NSException raise:NSRangeException
1526                 format:@"Index (%lu) beyond bounds (%lu)",
1527                        (unsigned long)idx2, (unsigned long)_count];
1528   }
1529   float temp = _values[idx1];
1530   _values[idx1] = _values[idx2];
1531   _values[idx2] = temp;
1532 }
1533
1534 @end
1535
1536 //%PDDM-EXPAND ARRAY_INTERFACE_SIMPLE(Double, double, %lf)
1537 // This block of code is generated, do not edit it directly.
1538
1539 #pragma mark - Double
1540
1541 @implementation GPBDoubleArray {
1542  @package
1543   double *_values;
1544   NSUInteger _count;
1545   NSUInteger _capacity;
1546 }
1547
1548 @synthesize count = _count;
1549
1550 + (instancetype)array {
1551   return [[[self alloc] init] autorelease];
1552 }
1553
1554 + (instancetype)arrayWithValue:(double)value {
1555   // Cast is needed so the compiler knows what class we are invoking initWithValues: on to get
1556   // the type correct.
1557   return [[(GPBDoubleArray*)[self alloc] initWithValues:&value count:1] autorelease];
1558 }
1559
1560 + (instancetype)arrayWithValueArray:(GPBDoubleArray *)array {
1561   return [[(GPBDoubleArray*)[self alloc] initWithValueArray:array] autorelease];
1562 }
1563
1564 + (instancetype)arrayWithCapacity:(NSUInteger)count {
1565   return [[[self alloc] initWithCapacity:count] autorelease];
1566 }
1567
1568 - (instancetype)init {
1569   self = [super init];
1570   // No work needed;
1571   return self;
1572 }
1573
1574 - (instancetype)initWithValueArray:(GPBDoubleArray *)array {
1575   return [self initWithValues:array->_values count:array->_count];
1576 }
1577
1578 - (instancetype)initWithValues:(const double [])values count:(NSUInteger)count {
1579   self = [self init];
1580   if (self) {
1581     if (count && values) {
1582       _values = reallocf(_values, count * sizeof(double));
1583       if (_values != NULL) {
1584         _capacity = count;
1585         memcpy(_values, values, count * sizeof(double));
1586         _count = count;
1587       } else {
1588         [self release];
1589         [NSException raise:NSMallocException
1590                     format:@"Failed to allocate %lu bytes",
1591                            (unsigned long)(count * sizeof(double))];
1592       }
1593     }
1594   }
1595   return self;
1596 }
1597
1598 - (instancetype)initWithCapacity:(NSUInteger)count {
1599   self = [self initWithValues:NULL count:0];
1600   if (self && count) {
1601     [self internalResizeToCapacity:count];
1602   }
1603   return self;
1604 }
1605
1606 - (instancetype)copyWithZone:(NSZone *)zone {
1607   return [[GPBDoubleArray allocWithZone:zone] initWithValues:_values count:_count];
1608 }
1609
1610 - (void)dealloc {
1611   NSAssert(!_autocreator,
1612            @"%@: Autocreator must be cleared before release, autocreator: %@",
1613            [self class], _autocreator);
1614   free(_values);
1615   [super dealloc];
1616 }
1617
1618 - (BOOL)isEqual:(id)other {
1619   if (self == other) {
1620     return YES;
1621   }
1622   if (![other isKindOfClass:[GPBDoubleArray class]]) {
1623     return NO;
1624   }
1625   GPBDoubleArray *otherArray = other;
1626   return (_count == otherArray->_count
1627           && memcmp(_values, otherArray->_values, (_count * sizeof(double))) == 0);
1628 }
1629
1630 - (NSUInteger)hash {
1631   // Follow NSArray's lead, and use the count as the hash.
1632   return _count;
1633 }
1634
1635 - (NSString *)description {
1636   NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> { ", [self class], self];
1637   for (NSUInteger i = 0, count = _count; i < count; ++i) {
1638     if (i == 0) {
1639       [result appendFormat:@"%lf", _values[i]];
1640     } else {
1641       [result appendFormat:@", %lf", _values[i]];
1642     }
1643   }
1644   [result appendFormat:@" }"];
1645   return result;
1646 }
1647
1648 - (void)enumerateValuesWithBlock:(void (^)(double value, NSUInteger idx, BOOL *stop))block {
1649   [self enumerateValuesWithOptions:(NSEnumerationOptions)0 usingBlock:block];
1650 }
1651
1652 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts
1653                         usingBlock:(void (^)(double value, NSUInteger idx, BOOL *stop))block {
1654   // NSEnumerationConcurrent isn't currently supported (and Apple's docs say that is ok).
1655   BOOL stop = NO;
1656   if ((opts & NSEnumerationReverse) == 0) {
1657     for (NSUInteger i = 0, count = _count; i < count; ++i) {
1658       block(_values[i], i, &stop);
1659       if (stop) break;
1660     }
1661   } else if (_count > 0) {
1662     for (NSUInteger i = _count; i > 0; --i) {
1663       block(_values[i - 1], (i - 1), &stop);
1664       if (stop) break;
1665     }
1666   }
1667 }
1668
1669 - (double)valueAtIndex:(NSUInteger)index {
1670   if (index >= _count) {
1671     [NSException raise:NSRangeException
1672                 format:@"Index (%lu) beyond bounds (%lu)",
1673                        (unsigned long)index, (unsigned long)_count];
1674   }
1675   return _values[index];
1676 }
1677
1678 - (void)internalResizeToCapacity:(NSUInteger)newCapacity {
1679   _values = reallocf(_values, newCapacity * sizeof(double));
1680   if (_values == NULL) {
1681     _capacity = 0;
1682     _count = 0;
1683     [NSException raise:NSMallocException
1684                 format:@"Failed to allocate %lu bytes",
1685                        (unsigned long)(newCapacity * sizeof(double))];
1686   }
1687   _capacity = newCapacity;
1688 }
1689
1690 - (void)addValue:(double)value {
1691   [self addValues:&value count:1];
1692 }
1693
1694 - (void)addValues:(const double [])values count:(NSUInteger)count {
1695   if (values == NULL || count == 0) return;
1696   NSUInteger initialCount = _count;
1697   NSUInteger newCount = initialCount + count;
1698   if (newCount > _capacity) {
1699     [self internalResizeToCapacity:CapacityFromCount(newCount)];
1700   }
1701   _count = newCount;
1702   memcpy(&_values[initialCount], values, count * sizeof(double));
1703   if (_autocreator) {
1704     GPBAutocreatedArrayModified(_autocreator, self);
1705   }
1706 }
1707
1708 - (void)insertValue:(double)value atIndex:(NSUInteger)index {
1709   if (index >= _count + 1) {
1710     [NSException raise:NSRangeException
1711                 format:@"Index (%lu) beyond bounds (%lu)",
1712                        (unsigned long)index, (unsigned long)_count + 1];
1713   }
1714   NSUInteger initialCount = _count;
1715   NSUInteger newCount = initialCount + 1;
1716   if (newCount > _capacity) {
1717     [self internalResizeToCapacity:CapacityFromCount(newCount)];
1718   }
1719   _count = newCount;
1720   if (index != initialCount) {
1721     memmove(&_values[index + 1], &_values[index], (initialCount - index) * sizeof(double));
1722   }
1723   _values[index] = value;
1724   if (_autocreator) {
1725     GPBAutocreatedArrayModified(_autocreator, self);
1726   }
1727 }
1728
1729 - (void)replaceValueAtIndex:(NSUInteger)index withValue:(double)value {
1730   if (index >= _count) {
1731     [NSException raise:NSRangeException
1732                 format:@"Index (%lu) beyond bounds (%lu)",
1733                        (unsigned long)index, (unsigned long)_count];
1734   }
1735   _values[index] = value;
1736 }
1737
1738 - (void)addValuesFromArray:(GPBDoubleArray *)array {
1739   [self addValues:array->_values count:array->_count];
1740 }
1741
1742 - (void)removeValueAtIndex:(NSUInteger)index {
1743   if (index >= _count) {
1744     [NSException raise:NSRangeException
1745                 format:@"Index (%lu) beyond bounds (%lu)",
1746                        (unsigned long)index, (unsigned long)_count];
1747   }
1748   NSUInteger newCount = _count - 1;
1749   if (index != newCount) {
1750     memmove(&_values[index], &_values[index + 1], (newCount - index) * sizeof(double));
1751   }
1752   _count = newCount;
1753   if ((newCount + (2 * kChunkSize)) < _capacity) {
1754     [self internalResizeToCapacity:CapacityFromCount(newCount)];
1755   }
1756 }
1757
1758 - (void)removeAll {
1759   _count = 0;
1760   if ((0 + (2 * kChunkSize)) < _capacity) {
1761     [self internalResizeToCapacity:CapacityFromCount(0)];
1762   }
1763 }
1764
1765 - (void)exchangeValueAtIndex:(NSUInteger)idx1
1766             withValueAtIndex:(NSUInteger)idx2 {
1767   if (idx1 >= _count) {
1768     [NSException raise:NSRangeException
1769                 format:@"Index (%lu) beyond bounds (%lu)",
1770                        (unsigned long)idx1, (unsigned long)_count];
1771   }
1772   if (idx2 >= _count) {
1773     [NSException raise:NSRangeException
1774                 format:@"Index (%lu) beyond bounds (%lu)",
1775                        (unsigned long)idx2, (unsigned long)_count];
1776   }
1777   double temp = _values[idx1];
1778   _values[idx1] = _values[idx2];
1779   _values[idx2] = temp;
1780 }
1781
1782 @end
1783
1784 //%PDDM-EXPAND ARRAY_INTERFACE_SIMPLE(Bool, BOOL, %d)
1785 // This block of code is generated, do not edit it directly.
1786
1787 #pragma mark - Bool
1788
1789 @implementation GPBBoolArray {
1790  @package
1791   BOOL *_values;
1792   NSUInteger _count;
1793   NSUInteger _capacity;
1794 }
1795
1796 @synthesize count = _count;
1797
1798 + (instancetype)array {
1799   return [[[self alloc] init] autorelease];
1800 }
1801
1802 + (instancetype)arrayWithValue:(BOOL)value {
1803   // Cast is needed so the compiler knows what class we are invoking initWithValues: on to get
1804   // the type correct.
1805   return [[(GPBBoolArray*)[self alloc] initWithValues:&value count:1] autorelease];
1806 }
1807
1808 + (instancetype)arrayWithValueArray:(GPBBoolArray *)array {
1809   return [[(GPBBoolArray*)[self alloc] initWithValueArray:array] autorelease];
1810 }
1811
1812 + (instancetype)arrayWithCapacity:(NSUInteger)count {
1813   return [[[self alloc] initWithCapacity:count] autorelease];
1814 }
1815
1816 - (instancetype)init {
1817   self = [super init];
1818   // No work needed;
1819   return self;
1820 }
1821
1822 - (instancetype)initWithValueArray:(GPBBoolArray *)array {
1823   return [self initWithValues:array->_values count:array->_count];
1824 }
1825
1826 - (instancetype)initWithValues:(const BOOL [])values count:(NSUInteger)count {
1827   self = [self init];
1828   if (self) {
1829     if (count && values) {
1830       _values = reallocf(_values, count * sizeof(BOOL));
1831       if (_values != NULL) {
1832         _capacity = count;
1833         memcpy(_values, values, count * sizeof(BOOL));
1834         _count = count;
1835       } else {
1836         [self release];
1837         [NSException raise:NSMallocException
1838                     format:@"Failed to allocate %lu bytes",
1839                            (unsigned long)(count * sizeof(BOOL))];
1840       }
1841     }
1842   }
1843   return self;
1844 }
1845
1846 - (instancetype)initWithCapacity:(NSUInteger)count {
1847   self = [self initWithValues:NULL count:0];
1848   if (self && count) {
1849     [self internalResizeToCapacity:count];
1850   }
1851   return self;
1852 }
1853
1854 - (instancetype)copyWithZone:(NSZone *)zone {
1855   return [[GPBBoolArray allocWithZone:zone] initWithValues:_values count:_count];
1856 }
1857
1858 - (void)dealloc {
1859   NSAssert(!_autocreator,
1860            @"%@: Autocreator must be cleared before release, autocreator: %@",
1861            [self class], _autocreator);
1862   free(_values);
1863   [super dealloc];
1864 }
1865
1866 - (BOOL)isEqual:(id)other {
1867   if (self == other) {
1868     return YES;
1869   }
1870   if (![other isKindOfClass:[GPBBoolArray class]]) {
1871     return NO;
1872   }
1873   GPBBoolArray *otherArray = other;
1874   return (_count == otherArray->_count
1875           && memcmp(_values, otherArray->_values, (_count * sizeof(BOOL))) == 0);
1876 }
1877
1878 - (NSUInteger)hash {
1879   // Follow NSArray's lead, and use the count as the hash.
1880   return _count;
1881 }
1882
1883 - (NSString *)description {
1884   NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> { ", [self class], self];
1885   for (NSUInteger i = 0, count = _count; i < count; ++i) {
1886     if (i == 0) {
1887       [result appendFormat:@"%d", _values[i]];
1888     } else {
1889       [result appendFormat:@", %d", _values[i]];
1890     }
1891   }
1892   [result appendFormat:@" }"];
1893   return result;
1894 }
1895
1896 - (void)enumerateValuesWithBlock:(void (^)(BOOL value, NSUInteger idx, BOOL *stop))block {
1897   [self enumerateValuesWithOptions:(NSEnumerationOptions)0 usingBlock:block];
1898 }
1899
1900 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts
1901                         usingBlock:(void (^)(BOOL value, NSUInteger idx, BOOL *stop))block {
1902   // NSEnumerationConcurrent isn't currently supported (and Apple's docs say that is ok).
1903   BOOL stop = NO;
1904   if ((opts & NSEnumerationReverse) == 0) {
1905     for (NSUInteger i = 0, count = _count; i < count; ++i) {
1906       block(_values[i], i, &stop);
1907       if (stop) break;
1908     }
1909   } else if (_count > 0) {
1910     for (NSUInteger i = _count; i > 0; --i) {
1911       block(_values[i - 1], (i - 1), &stop);
1912       if (stop) break;
1913     }
1914   }
1915 }
1916
1917 - (BOOL)valueAtIndex:(NSUInteger)index {
1918   if (index >= _count) {
1919     [NSException raise:NSRangeException
1920                 format:@"Index (%lu) beyond bounds (%lu)",
1921                        (unsigned long)index, (unsigned long)_count];
1922   }
1923   return _values[index];
1924 }
1925
1926 - (void)internalResizeToCapacity:(NSUInteger)newCapacity {
1927   _values = reallocf(_values, newCapacity * sizeof(BOOL));
1928   if (_values == NULL) {
1929     _capacity = 0;
1930     _count = 0;
1931     [NSException raise:NSMallocException
1932                 format:@"Failed to allocate %lu bytes",
1933                        (unsigned long)(newCapacity * sizeof(BOOL))];
1934   }
1935   _capacity = newCapacity;
1936 }
1937
1938 - (void)addValue:(BOOL)value {
1939   [self addValues:&value count:1];
1940 }
1941
1942 - (void)addValues:(const BOOL [])values count:(NSUInteger)count {
1943   if (values == NULL || count == 0) return;
1944   NSUInteger initialCount = _count;
1945   NSUInteger newCount = initialCount + count;
1946   if (newCount > _capacity) {
1947     [self internalResizeToCapacity:CapacityFromCount(newCount)];
1948   }
1949   _count = newCount;
1950   memcpy(&_values[initialCount], values, count * sizeof(BOOL));
1951   if (_autocreator) {
1952     GPBAutocreatedArrayModified(_autocreator, self);
1953   }
1954 }
1955
1956 - (void)insertValue:(BOOL)value atIndex:(NSUInteger)index {
1957   if (index >= _count + 1) {
1958     [NSException raise:NSRangeException
1959                 format:@"Index (%lu) beyond bounds (%lu)",
1960                        (unsigned long)index, (unsigned long)_count + 1];
1961   }
1962   NSUInteger initialCount = _count;
1963   NSUInteger newCount = initialCount + 1;
1964   if (newCount > _capacity) {
1965     [self internalResizeToCapacity:CapacityFromCount(newCount)];
1966   }
1967   _count = newCount;
1968   if (index != initialCount) {
1969     memmove(&_values[index + 1], &_values[index], (initialCount - index) * sizeof(BOOL));
1970   }
1971   _values[index] = value;
1972   if (_autocreator) {
1973     GPBAutocreatedArrayModified(_autocreator, self);
1974   }
1975 }
1976
1977 - (void)replaceValueAtIndex:(NSUInteger)index withValue:(BOOL)value {
1978   if (index >= _count) {
1979     [NSException raise:NSRangeException
1980                 format:@"Index (%lu) beyond bounds (%lu)",
1981                        (unsigned long)index, (unsigned long)_count];
1982   }
1983   _values[index] = value;
1984 }
1985
1986 - (void)addValuesFromArray:(GPBBoolArray *)array {
1987   [self addValues:array->_values count:array->_count];
1988 }
1989
1990 - (void)removeValueAtIndex:(NSUInteger)index {
1991   if (index >= _count) {
1992     [NSException raise:NSRangeException
1993                 format:@"Index (%lu) beyond bounds (%lu)",
1994                        (unsigned long)index, (unsigned long)_count];
1995   }
1996   NSUInteger newCount = _count - 1;
1997   if (index != newCount) {
1998     memmove(&_values[index], &_values[index + 1], (newCount - index) * sizeof(BOOL));
1999   }
2000   _count = newCount;
2001   if ((newCount + (2 * kChunkSize)) < _capacity) {
2002     [self internalResizeToCapacity:CapacityFromCount(newCount)];
2003   }
2004 }
2005
2006 - (void)removeAll {
2007   _count = 0;
2008   if ((0 + (2 * kChunkSize)) < _capacity) {
2009     [self internalResizeToCapacity:CapacityFromCount(0)];
2010   }
2011 }
2012
2013 - (void)exchangeValueAtIndex:(NSUInteger)idx1
2014             withValueAtIndex:(NSUInteger)idx2 {
2015   if (idx1 >= _count) {
2016     [NSException raise:NSRangeException
2017                 format:@"Index (%lu) beyond bounds (%lu)",
2018                        (unsigned long)idx1, (unsigned long)_count];
2019   }
2020   if (idx2 >= _count) {
2021     [NSException raise:NSRangeException
2022                 format:@"Index (%lu) beyond bounds (%lu)",
2023                        (unsigned long)idx2, (unsigned long)_count];
2024   }
2025   BOOL temp = _values[idx1];
2026   _values[idx1] = _values[idx2];
2027   _values[idx2] = temp;
2028 }
2029
2030 @end
2031
2032 //%PDDM-EXPAND-END (7 expansions)
2033
2034 #pragma mark - Enum
2035
2036 @implementation GPBEnumArray {
2037  @package
2038   GPBEnumValidationFunc _validationFunc;
2039   int32_t *_values;
2040   NSUInteger _count;
2041   NSUInteger _capacity;
2042 }
2043
2044 @synthesize count = _count;
2045 @synthesize validationFunc = _validationFunc;
2046
2047 + (instancetype)array {
2048   return [[[self alloc] initWithValidationFunction:NULL] autorelease];
2049 }
2050
2051 + (instancetype)arrayWithValidationFunction:(GPBEnumValidationFunc)func {
2052   return [[[self alloc] initWithValidationFunction:func] autorelease];
2053 }
2054
2055 + (instancetype)arrayWithValidationFunction:(GPBEnumValidationFunc)func
2056                                    rawValue:(int32_t)value {
2057   return [[[self alloc] initWithValidationFunction:func
2058                                          rawValues:&value
2059                                              count:1] autorelease];
2060 }
2061
2062 + (instancetype)arrayWithValueArray:(GPBEnumArray *)array {
2063   return [[(GPBEnumArray*)[self alloc] initWithValueArray:array] autorelease];
2064 }
2065
2066 + (instancetype)arrayWithValidationFunction:(GPBEnumValidationFunc)func
2067                                    capacity:(NSUInteger)count {
2068   return [[[self alloc] initWithValidationFunction:func capacity:count] autorelease];
2069 }
2070
2071 - (instancetype)init {
2072   return [self initWithValidationFunction:NULL];
2073 }
2074
2075 - (instancetype)initWithValueArray:(GPBEnumArray *)array {
2076   return [self initWithValidationFunction:array->_validationFunc
2077                                 rawValues:array->_values
2078                                     count:array->_count];
2079 }
2080
2081 - (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func {
2082   self = [super init];
2083   if (self) {
2084     _validationFunc = (func != NULL ? func : ArrayDefault_IsValidValue);
2085   }
2086   return self;
2087 }
2088
2089 - (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func
2090                                  rawValues:(const int32_t [])values
2091                                      count:(NSUInteger)count {
2092   self = [self initWithValidationFunction:func];
2093   if (self) {
2094     if (count && values) {
2095       _values = reallocf(_values, count * sizeof(int32_t));
2096       if (_values != NULL) {
2097         _capacity = count;
2098         memcpy(_values, values, count * sizeof(int32_t));
2099         _count = count;
2100       } else {
2101         [self release];
2102         [NSException raise:NSMallocException
2103                     format:@"Failed to allocate %lu bytes",
2104                            (unsigned long)(count * sizeof(int32_t))];
2105       }
2106     }
2107   }
2108   return self;
2109 }
2110
2111 - (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func
2112                                   capacity:(NSUInteger)count {
2113   self = [self initWithValidationFunction:func];
2114   if (self && count) {
2115     [self internalResizeToCapacity:count];
2116   }
2117   return self;
2118 }
2119
2120 - (instancetype)copyWithZone:(NSZone *)zone {
2121   return [[GPBEnumArray allocWithZone:zone]
2122              initWithValidationFunction:_validationFunc
2123                               rawValues:_values
2124                                   count:_count];
2125 }
2126
2127 //%PDDM-EXPAND ARRAY_IMMUTABLE_CORE(Enum, int32_t, Raw, %d)
2128 // This block of code is generated, do not edit it directly.
2129
2130 - (void)dealloc {
2131   NSAssert(!_autocreator,
2132            @"%@: Autocreator must be cleared before release, autocreator: %@",
2133            [self class], _autocreator);
2134   free(_values);
2135   [super dealloc];
2136 }
2137
2138 - (BOOL)isEqual:(id)other {
2139   if (self == other) {
2140     return YES;
2141   }
2142   if (![other isKindOfClass:[GPBEnumArray class]]) {
2143     return NO;
2144   }
2145   GPBEnumArray *otherArray = other;
2146   return (_count == otherArray->_count
2147           && memcmp(_values, otherArray->_values, (_count * sizeof(int32_t))) == 0);
2148 }
2149
2150 - (NSUInteger)hash {
2151   // Follow NSArray's lead, and use the count as the hash.
2152   return _count;
2153 }
2154
2155 - (NSString *)description {
2156   NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> { ", [self class], self];
2157   for (NSUInteger i = 0, count = _count; i < count; ++i) {
2158     if (i == 0) {
2159       [result appendFormat:@"%d", _values[i]];
2160     } else {
2161       [result appendFormat:@", %d", _values[i]];
2162     }
2163   }
2164   [result appendFormat:@" }"];
2165   return result;
2166 }
2167
2168 - (void)enumerateRawValuesWithBlock:(void (^)(int32_t value, NSUInteger idx, BOOL *stop))block {
2169   [self enumerateRawValuesWithOptions:(NSEnumerationOptions)0 usingBlock:block];
2170 }
2171
2172 - (void)enumerateRawValuesWithOptions:(NSEnumerationOptions)opts
2173                            usingBlock:(void (^)(int32_t value, NSUInteger idx, BOOL *stop))block {
2174   // NSEnumerationConcurrent isn't currently supported (and Apple's docs say that is ok).
2175   BOOL stop = NO;
2176   if ((opts & NSEnumerationReverse) == 0) {
2177     for (NSUInteger i = 0, count = _count; i < count; ++i) {
2178       block(_values[i], i, &stop);
2179       if (stop) break;
2180     }
2181   } else if (_count > 0) {
2182     for (NSUInteger i = _count; i > 0; --i) {
2183       block(_values[i - 1], (i - 1), &stop);
2184       if (stop) break;
2185     }
2186   }
2187 }
2188 //%PDDM-EXPAND-END ARRAY_IMMUTABLE_CORE(Enum, int32_t, Raw, %d)
2189
2190 - (int32_t)valueAtIndex:(NSUInteger)index {
2191 //%PDDM-EXPAND VALIDATE_RANGE(index, _count)
2192 // This block of code is generated, do not edit it directly.
2193
2194   if (index >= _count) {
2195     [NSException raise:NSRangeException
2196                 format:@"Index (%lu) beyond bounds (%lu)",
2197                        (unsigned long)index, (unsigned long)_count];
2198   }
2199 //%PDDM-EXPAND-END VALIDATE_RANGE(index, _count)
2200   int32_t result = _values[index];
2201   if (!_validationFunc(result)) {
2202     result = kGPBUnrecognizedEnumeratorValue;
2203   }
2204   return result;
2205 }
2206
2207 - (int32_t)rawValueAtIndex:(NSUInteger)index {
2208 //%PDDM-EXPAND VALIDATE_RANGE(index, _count)
2209 // This block of code is generated, do not edit it directly.
2210
2211   if (index >= _count) {
2212     [NSException raise:NSRangeException
2213                 format:@"Index (%lu) beyond bounds (%lu)",
2214                        (unsigned long)index, (unsigned long)_count];
2215   }
2216 //%PDDM-EXPAND-END VALIDATE_RANGE(index, _count)
2217   return _values[index];
2218 }
2219
2220 - (void)enumerateValuesWithBlock:(void (^)(int32_t value, NSUInteger idx, BOOL *stop))block {
2221   [self enumerateValuesWithOptions:(NSEnumerationOptions)0 usingBlock:block];
2222 }
2223
2224 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts
2225                         usingBlock:(void (^)(int32_t value, NSUInteger idx, BOOL *stop))block {
2226   // NSEnumerationConcurrent isn't currently supported (and Apple's docs say that is ok).
2227   BOOL stop = NO;
2228   GPBEnumValidationFunc func = _validationFunc;
2229   if ((opts & NSEnumerationReverse) == 0) {
2230     int32_t *scan = _values;
2231     int32_t *end = scan + _count;
2232     for (NSUInteger i = 0; scan < end; ++i, ++scan) {
2233       int32_t value = *scan;
2234       if (!func(value)) {
2235         value = kGPBUnrecognizedEnumeratorValue;
2236       }
2237       block(value, i, &stop);
2238       if (stop) break;
2239     }
2240   } else if (_count > 0) {
2241     int32_t *end = _values;
2242     int32_t *scan = end + (_count - 1);
2243     for (NSUInteger i = (_count - 1); scan >= end; --i, --scan) {
2244       int32_t value = *scan;
2245       if (!func(value)) {
2246         value = kGPBUnrecognizedEnumeratorValue;
2247       }
2248       block(value, i, &stop);
2249       if (stop) break;
2250     }
2251   }
2252 }
2253
2254 //%PDDM-EXPAND ARRAY_MUTABLE_CORE(Enum, int32_t, Raw, %d)
2255 // This block of code is generated, do not edit it directly.
2256
2257 - (void)internalResizeToCapacity:(NSUInteger)newCapacity {
2258   _values = reallocf(_values, newCapacity * sizeof(int32_t));
2259   if (_values == NULL) {
2260     _capacity = 0;
2261     _count = 0;
2262     [NSException raise:NSMallocException
2263                 format:@"Failed to allocate %lu bytes",
2264                        (unsigned long)(newCapacity * sizeof(int32_t))];
2265   }
2266   _capacity = newCapacity;
2267 }
2268
2269 - (void)addRawValue:(int32_t)value {
2270   [self addRawValues:&value count:1];
2271 }
2272
2273 - (void)addRawValues:(const int32_t [])values count:(NSUInteger)count {
2274   if (values == NULL || count == 0) return;
2275   NSUInteger initialCount = _count;
2276   NSUInteger newCount = initialCount + count;
2277   if (newCount > _capacity) {
2278     [self internalResizeToCapacity:CapacityFromCount(newCount)];
2279   }
2280   _count = newCount;
2281   memcpy(&_values[initialCount], values, count * sizeof(int32_t));
2282   if (_autocreator) {
2283     GPBAutocreatedArrayModified(_autocreator, self);
2284   }
2285 }
2286
2287 - (void)insertRawValue:(int32_t)value atIndex:(NSUInteger)index {
2288   if (index >= _count + 1) {
2289     [NSException raise:NSRangeException
2290                 format:@"Index (%lu) beyond bounds (%lu)",
2291                        (unsigned long)index, (unsigned long)_count + 1];
2292   }
2293   NSUInteger initialCount = _count;
2294   NSUInteger newCount = initialCount + 1;
2295   if (newCount > _capacity) {
2296     [self internalResizeToCapacity:CapacityFromCount(newCount)];
2297   }
2298   _count = newCount;
2299   if (index != initialCount) {
2300     memmove(&_values[index + 1], &_values[index], (initialCount - index) * sizeof(int32_t));
2301   }
2302   _values[index] = value;
2303   if (_autocreator) {
2304     GPBAutocreatedArrayModified(_autocreator, self);
2305   }
2306 }
2307
2308 - (void)replaceValueAtIndex:(NSUInteger)index withRawValue:(int32_t)value {
2309   if (index >= _count) {
2310     [NSException raise:NSRangeException
2311                 format:@"Index (%lu) beyond bounds (%lu)",
2312                        (unsigned long)index, (unsigned long)_count];
2313   }
2314   _values[index] = value;
2315 }
2316
2317 - (void)addRawValuesFromArray:(GPBEnumArray *)array {
2318   [self addRawValues:array->_values count:array->_count];
2319 }
2320
2321 - (void)removeValueAtIndex:(NSUInteger)index {
2322   if (index >= _count) {
2323     [NSException raise:NSRangeException
2324                 format:@"Index (%lu) beyond bounds (%lu)",
2325                        (unsigned long)index, (unsigned long)_count];
2326   }
2327   NSUInteger newCount = _count - 1;
2328   if (index != newCount) {
2329     memmove(&_values[index], &_values[index + 1], (newCount - index) * sizeof(int32_t));
2330   }
2331   _count = newCount;
2332   if ((newCount + (2 * kChunkSize)) < _capacity) {
2333     [self internalResizeToCapacity:CapacityFromCount(newCount)];
2334   }
2335 }
2336
2337 - (void)removeAll {
2338   _count = 0;
2339   if ((0 + (2 * kChunkSize)) < _capacity) {
2340     [self internalResizeToCapacity:CapacityFromCount(0)];
2341   }
2342 }
2343
2344 - (void)exchangeValueAtIndex:(NSUInteger)idx1
2345             withValueAtIndex:(NSUInteger)idx2 {
2346   if (idx1 >= _count) {
2347     [NSException raise:NSRangeException
2348                 format:@"Index (%lu) beyond bounds (%lu)",
2349                        (unsigned long)idx1, (unsigned long)_count];
2350   }
2351   if (idx2 >= _count) {
2352     [NSException raise:NSRangeException
2353                 format:@"Index (%lu) beyond bounds (%lu)",
2354                        (unsigned long)idx2, (unsigned long)_count];
2355   }
2356   int32_t temp = _values[idx1];
2357   _values[idx1] = _values[idx2];
2358   _values[idx2] = temp;
2359 }
2360
2361 //%PDDM-EXPAND MUTATION_METHODS(Enum, int32_t, , EnumValidationList, EnumValidationOne)
2362 // This block of code is generated, do not edit it directly.
2363
2364 - (void)addValue:(int32_t)value {
2365   [self addValues:&value count:1];
2366 }
2367
2368 - (void)addValues:(const int32_t [])values count:(NSUInteger)count {
2369   if (values == NULL || count == 0) return;
2370   GPBEnumValidationFunc func = _validationFunc;
2371   for (NSUInteger i = 0; i < count; ++i) {
2372     if (!func(values[i])) {
2373       [NSException raise:NSInvalidArgumentException
2374                   format:@"%@: Attempt to set an unknown enum value (%d)",
2375                          [self class], values[i]];
2376     }
2377   }
2378   NSUInteger initialCount = _count;
2379   NSUInteger newCount = initialCount + count;
2380   if (newCount > _capacity) {
2381     [self internalResizeToCapacity:CapacityFromCount(newCount)];
2382   }
2383   _count = newCount;
2384   memcpy(&_values[initialCount], values, count * sizeof(int32_t));
2385   if (_autocreator) {
2386     GPBAutocreatedArrayModified(_autocreator, self);
2387   }
2388 }
2389
2390 - (void)insertValue:(int32_t)value atIndex:(NSUInteger)index {
2391   if (index >= _count + 1) {
2392     [NSException raise:NSRangeException
2393                 format:@"Index (%lu) beyond bounds (%lu)",
2394                        (unsigned long)index, (unsigned long)_count + 1];
2395   }
2396   if (!_validationFunc(value)) {
2397     [NSException raise:NSInvalidArgumentException
2398                 format:@"%@: Attempt to set an unknown enum value (%d)",
2399                        [self class], value];
2400   }
2401   NSUInteger initialCount = _count;
2402   NSUInteger newCount = initialCount + 1;
2403   if (newCount > _capacity) {
2404     [self internalResizeToCapacity:CapacityFromCount(newCount)];
2405   }
2406   _count = newCount;
2407   if (index != initialCount) {
2408     memmove(&_values[index + 1], &_values[index], (initialCount - index) * sizeof(int32_t));
2409   }
2410   _values[index] = value;
2411   if (_autocreator) {
2412     GPBAutocreatedArrayModified(_autocreator, self);
2413   }
2414 }
2415
2416 - (void)replaceValueAtIndex:(NSUInteger)index withValue:(int32_t)value {
2417   if (index >= _count) {
2418     [NSException raise:NSRangeException
2419                 format:@"Index (%lu) beyond bounds (%lu)",
2420                        (unsigned long)index, (unsigned long)_count];
2421   }
2422   if (!_validationFunc(value)) {
2423     [NSException raise:NSInvalidArgumentException
2424                 format:@"%@: Attempt to set an unknown enum value (%d)",
2425                        [self class], value];
2426   }
2427   _values[index] = value;
2428 }
2429 //%PDDM-EXPAND-END (2 expansions)
2430
2431 //%PDDM-DEFINE MUTATION_HOOK_EnumValidationList()
2432 //%  GPBEnumValidationFunc func = _validationFunc;
2433 //%  for (NSUInteger i = 0; i < count; ++i) {
2434 //%    if (!func(values[i])) {
2435 //%      [NSException raise:NSInvalidArgumentException
2436 //%                  format:@"%@: Attempt to set an unknown enum value (%d)",
2437 //%                         [self class], values[i]];
2438 //%    }
2439 //%  }
2440 //%
2441 //%PDDM-DEFINE MUTATION_HOOK_EnumValidationOne()
2442 //%  if (!_validationFunc(value)) {
2443 //%    [NSException raise:NSInvalidArgumentException
2444 //%                format:@"%@: Attempt to set an unknown enum value (%d)",
2445 //%                       [self class], value];
2446 //%  }
2447 //%
2448
2449 @end
2450
2451 #pragma mark - NSArray Subclass
2452
2453 @implementation GPBAutocreatedArray {
2454   NSMutableArray *_array;
2455 }
2456
2457 - (void)dealloc {
2458   NSAssert(!_autocreator,
2459            @"%@: Autocreator must be cleared before release, autocreator: %@",
2460            [self class], _autocreator);
2461   [_array release];
2462   [super dealloc];
2463 }
2464
2465 #pragma mark Required NSArray overrides
2466
2467 - (NSUInteger)count {
2468   return [_array count];
2469 }
2470
2471 - (id)objectAtIndex:(NSUInteger)idx {
2472   return [_array objectAtIndex:idx];
2473 }
2474
2475 #pragma mark Required NSMutableArray overrides
2476
2477 // Only need to call GPBAutocreatedArrayModified() when adding things since
2478 // we only autocreate empty arrays.
2479
2480 - (void)insertObject:(id)anObject atIndex:(NSUInteger)idx {
2481   if (_array == nil) {
2482     _array = [[NSMutableArray alloc] init];
2483   }
2484   [_array insertObject:anObject atIndex:idx];
2485
2486   if (_autocreator) {
2487     GPBAutocreatedArrayModified(_autocreator, self);
2488   }
2489 }
2490
2491 - (void)removeObject:(id)anObject {
2492   [_array removeObject:anObject];
2493 }
2494
2495 - (void)removeObjectAtIndex:(NSUInteger)idx {
2496   [_array removeObjectAtIndex:idx];
2497 }
2498
2499 - (void)addObject:(id)anObject {
2500   if (_array == nil) {
2501     _array = [[NSMutableArray alloc] init];
2502   }
2503   [_array addObject:anObject];
2504
2505   if (_autocreator) {
2506     GPBAutocreatedArrayModified(_autocreator, self);
2507   }
2508 }
2509
2510 - (void)removeLastObject {
2511   [_array removeLastObject];
2512 }
2513
2514 - (void)replaceObjectAtIndex:(NSUInteger)idx withObject:(id)anObject {
2515   [_array replaceObjectAtIndex:idx withObject:anObject];
2516 }
2517
2518 #pragma mark Extra things hooked
2519
2520 - (id)copyWithZone:(NSZone *)zone {
2521   if (_array == nil) {
2522     return [[NSMutableArray allocWithZone:zone] init];
2523   }
2524   return [_array copyWithZone:zone];
2525 }
2526
2527 - (id)mutableCopyWithZone:(NSZone *)zone {
2528   if (_array == nil) {
2529     return [[NSMutableArray allocWithZone:zone] init];
2530   }
2531   return [_array mutableCopyWithZone:zone];
2532 }
2533
2534 - (NSUInteger)countByEnumeratingWithState:(NSFastEnumerationState *)state
2535                                   objects:(id __unsafe_unretained [])buffer
2536                                     count:(NSUInteger)len {
2537   return [_array countByEnumeratingWithState:state objects:buffer count:len];
2538 }
2539
2540 - (void)enumerateObjectsUsingBlock:(void (NS_NOESCAPE ^)(id obj, NSUInteger idx, BOOL *stop))block {
2541   [_array enumerateObjectsUsingBlock:block];
2542 }
2543
2544 - (void)enumerateObjectsWithOptions:(NSEnumerationOptions)opts
2545                          usingBlock:(void (NS_NOESCAPE ^)(id obj, NSUInteger idx, BOOL *stop))block {
2546   [_array enumerateObjectsWithOptions:opts usingBlock:block];
2547 }
2548
2549 @end
2550
2551 #pragma clang diagnostic pop