• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1// Protocol Buffers - Google's data interchange format
2// Copyright 2008 Google Inc.  All rights reserved.
3//
4// Use of this source code is governed by a BSD-style
5// license that can be found in the LICENSE file or at
6// https://developers.google.com/open-source/licenses/bsd
7
8#import "GPBDictionary.h"
9#import "GPBDictionary_PackagePrivate.h"
10
11#import "GPBCodedInputStream.h"
12#import "GPBCodedInputStream_PackagePrivate.h"
13#import "GPBCodedOutputStream.h"
14#import "GPBCodedOutputStream_PackagePrivate.h"
15#import "GPBDescriptor.h"
16#import "GPBDescriptor_PackagePrivate.h"
17#import "GPBMessage.h"
18#import "GPBMessage_PackagePrivate.h"
19#import "GPBUtilities.h"
20#import "GPBUtilities_PackagePrivate.h"
21
22// ------------------------------ NOTE ------------------------------
23// At the moment, this is all using NSNumbers in NSDictionaries under
24// the hood, but it is all hidden so we can come back and optimize
25// with direct CFDictionary usage later.  The reason that wasn't
26// done yet is needing to support 32bit iOS builds.  Otherwise
27// it would be pretty simple to store all this data in CFDictionaries
28// directly.
29// ------------------------------------------------------------------
30
31// Direct access is use for speed, to avoid even internally declaring things
32// read/write, etc. The warning is enabled in the project to ensure code calling
33// protos can turn on -Wdirect-ivar-access without issues.
34#pragma clang diagnostic push
35#pragma clang diagnostic ignored "-Wdirect-ivar-access"
36
37enum {
38  kMapKeyFieldNumber = 1,
39  kMapValueFieldNumber = 2,
40};
41
42static BOOL DictDefault_IsValidValue(int32_t value) {
43  // Anything but the bad value marker is allowed.
44  return (value != kGPBUnrecognizedEnumeratorValue);
45}
46
47// Disable clang-format for the macros.
48// clang-format off
49
50//%PDDM-DEFINE SERIALIZE_SUPPORT_2_TYPE(VALUE_NAME, VALUE_TYPE, GPBDATATYPE_NAME1, GPBDATATYPE_NAME2)
51//%static size_t ComputeDict##VALUE_NAME##FieldSize(VALUE_TYPE value, uint32_t fieldNum, GPBDataType dataType) {
52//%  if (dataType == GPBDataType##GPBDATATYPE_NAME1) {
53//%    return GPBCompute##GPBDATATYPE_NAME1##Size(fieldNum, value);
54//%  } else if (dataType == GPBDataType##GPBDATATYPE_NAME2) {
55//%    return GPBCompute##GPBDATATYPE_NAME2##Size(fieldNum, value);
56//%  } else {
57//%    NSCAssert(NO, @"Unexpected type %d", dataType);
58//%    return 0;
59//%  }
60//%}
61//%
62//%static void WriteDict##VALUE_NAME##Field(GPBCodedOutputStream *stream, VALUE_TYPE value, uint32_t fieldNum, GPBDataType dataType) {
63//%  if (dataType == GPBDataType##GPBDATATYPE_NAME1) {
64//%    [stream write##GPBDATATYPE_NAME1##:fieldNum value:value];
65//%  } else if (dataType == GPBDataType##GPBDATATYPE_NAME2) {
66//%    [stream write##GPBDATATYPE_NAME2##:fieldNum value:value];
67//%  } else {
68//%    NSCAssert(NO, @"Unexpected type %d", dataType);
69//%  }
70//%}
71//%
72//%PDDM-DEFINE SERIALIZE_SUPPORT_3_TYPE(VALUE_NAME, VALUE_TYPE, GPBDATATYPE_NAME1, GPBDATATYPE_NAME2, GPBDATATYPE_NAME3)
73//%static size_t ComputeDict##VALUE_NAME##FieldSize(VALUE_TYPE value, uint32_t fieldNum, GPBDataType dataType) {
74//%  if (dataType == GPBDataType##GPBDATATYPE_NAME1) {
75//%    return GPBCompute##GPBDATATYPE_NAME1##Size(fieldNum, value);
76//%  } else if (dataType == GPBDataType##GPBDATATYPE_NAME2) {
77//%    return GPBCompute##GPBDATATYPE_NAME2##Size(fieldNum, value);
78//%  } else if (dataType == GPBDataType##GPBDATATYPE_NAME3) {
79//%    return GPBCompute##GPBDATATYPE_NAME3##Size(fieldNum, value);
80//%  } else {
81//%    NSCAssert(NO, @"Unexpected type %d", dataType);
82//%    return 0;
83//%  }
84//%}
85//%
86//%static void WriteDict##VALUE_NAME##Field(GPBCodedOutputStream *stream, VALUE_TYPE value, uint32_t fieldNum, GPBDataType dataType) {
87//%  if (dataType == GPBDataType##GPBDATATYPE_NAME1) {
88//%    [stream write##GPBDATATYPE_NAME1##:fieldNum value:value];
89//%  } else if (dataType == GPBDataType##GPBDATATYPE_NAME2) {
90//%    [stream write##GPBDATATYPE_NAME2##:fieldNum value:value];
91//%  } else if (dataType == GPBDataType##GPBDATATYPE_NAME3) {
92//%    [stream write##GPBDATATYPE_NAME3##:fieldNum value:value];
93//%  } else {
94//%    NSCAssert(NO, @"Unexpected type %d", dataType);
95//%  }
96//%}
97//%
98//%PDDM-DEFINE SIMPLE_SERIALIZE_SUPPORT(VALUE_NAME, VALUE_TYPE, VisP)
99//%static size_t ComputeDict##VALUE_NAME##FieldSize(VALUE_TYPE VisP##value, uint32_t fieldNum, __unused GPBDataType dataType) {
100//%  NSCAssert(dataType == GPBDataType##VALUE_NAME, @"bad type: %d", dataType);
101//%  return GPBCompute##VALUE_NAME##Size(fieldNum, value);
102//%}
103//%
104//%static void WriteDict##VALUE_NAME##Field(GPBCodedOutputStream *stream, VALUE_TYPE VisP##value, uint32_t fieldNum, __unused GPBDataType dataType) {
105//%  NSCAssert(dataType == GPBDataType##VALUE_NAME, @"bad type: %d", dataType);
106//%  [stream write##VALUE_NAME##:fieldNum value:value];
107//%}
108//%
109//%PDDM-DEFINE SERIALIZE_SUPPORT_HELPERS()
110//%SERIALIZE_SUPPORT_3_TYPE(Int32, int32_t, Int32, SInt32, SFixed32)
111//%SERIALIZE_SUPPORT_2_TYPE(UInt32, uint32_t, UInt32, Fixed32)
112//%SERIALIZE_SUPPORT_3_TYPE(Int64, int64_t, Int64, SInt64, SFixed64)
113//%SERIALIZE_SUPPORT_2_TYPE(UInt64, uint64_t, UInt64, Fixed64)
114//%SIMPLE_SERIALIZE_SUPPORT(Bool, BOOL, )
115//%SIMPLE_SERIALIZE_SUPPORT(Enum, int32_t, )
116//%SIMPLE_SERIALIZE_SUPPORT(Float, float, )
117//%SIMPLE_SERIALIZE_SUPPORT(Double, double, )
118//%SIMPLE_SERIALIZE_SUPPORT(String, NSString, *)
119//%SERIALIZE_SUPPORT_3_TYPE(Object, id, Message, String, Bytes)
120//%PDDM-EXPAND SERIALIZE_SUPPORT_HELPERS()
121// This block of code is generated, do not edit it directly.
122
123static size_t ComputeDictInt32FieldSize(int32_t value, uint32_t fieldNum, GPBDataType dataType) {
124  if (dataType == GPBDataTypeInt32) {
125    return GPBComputeInt32Size(fieldNum, value);
126  } else if (dataType == GPBDataTypeSInt32) {
127    return GPBComputeSInt32Size(fieldNum, value);
128  } else if (dataType == GPBDataTypeSFixed32) {
129    return GPBComputeSFixed32Size(fieldNum, value);
130  } else {
131    NSCAssert(NO, @"Unexpected type %d", dataType);
132    return 0;
133  }
134}
135
136static void WriteDictInt32Field(GPBCodedOutputStream *stream, int32_t value, uint32_t fieldNum, GPBDataType dataType) {
137  if (dataType == GPBDataTypeInt32) {
138    [stream writeInt32:fieldNum value:value];
139  } else if (dataType == GPBDataTypeSInt32) {
140    [stream writeSInt32:fieldNum value:value];
141  } else if (dataType == GPBDataTypeSFixed32) {
142    [stream writeSFixed32:fieldNum value:value];
143  } else {
144    NSCAssert(NO, @"Unexpected type %d", dataType);
145  }
146}
147
148static size_t ComputeDictUInt32FieldSize(uint32_t value, uint32_t fieldNum, GPBDataType dataType) {
149  if (dataType == GPBDataTypeUInt32) {
150    return GPBComputeUInt32Size(fieldNum, value);
151  } else if (dataType == GPBDataTypeFixed32) {
152    return GPBComputeFixed32Size(fieldNum, value);
153  } else {
154    NSCAssert(NO, @"Unexpected type %d", dataType);
155    return 0;
156  }
157}
158
159static void WriteDictUInt32Field(GPBCodedOutputStream *stream, uint32_t value, uint32_t fieldNum, GPBDataType dataType) {
160  if (dataType == GPBDataTypeUInt32) {
161    [stream writeUInt32:fieldNum value:value];
162  } else if (dataType == GPBDataTypeFixed32) {
163    [stream writeFixed32:fieldNum value:value];
164  } else {
165    NSCAssert(NO, @"Unexpected type %d", dataType);
166  }
167}
168
169static size_t ComputeDictInt64FieldSize(int64_t value, uint32_t fieldNum, GPBDataType dataType) {
170  if (dataType == GPBDataTypeInt64) {
171    return GPBComputeInt64Size(fieldNum, value);
172  } else if (dataType == GPBDataTypeSInt64) {
173    return GPBComputeSInt64Size(fieldNum, value);
174  } else if (dataType == GPBDataTypeSFixed64) {
175    return GPBComputeSFixed64Size(fieldNum, value);
176  } else {
177    NSCAssert(NO, @"Unexpected type %d", dataType);
178    return 0;
179  }
180}
181
182static void WriteDictInt64Field(GPBCodedOutputStream *stream, int64_t value, uint32_t fieldNum, GPBDataType dataType) {
183  if (dataType == GPBDataTypeInt64) {
184    [stream writeInt64:fieldNum value:value];
185  } else if (dataType == GPBDataTypeSInt64) {
186    [stream writeSInt64:fieldNum value:value];
187  } else if (dataType == GPBDataTypeSFixed64) {
188    [stream writeSFixed64:fieldNum value:value];
189  } else {
190    NSCAssert(NO, @"Unexpected type %d", dataType);
191  }
192}
193
194static size_t ComputeDictUInt64FieldSize(uint64_t value, uint32_t fieldNum, GPBDataType dataType) {
195  if (dataType == GPBDataTypeUInt64) {
196    return GPBComputeUInt64Size(fieldNum, value);
197  } else if (dataType == GPBDataTypeFixed64) {
198    return GPBComputeFixed64Size(fieldNum, value);
199  } else {
200    NSCAssert(NO, @"Unexpected type %d", dataType);
201    return 0;
202  }
203}
204
205static void WriteDictUInt64Field(GPBCodedOutputStream *stream, uint64_t value, uint32_t fieldNum, GPBDataType dataType) {
206  if (dataType == GPBDataTypeUInt64) {
207    [stream writeUInt64:fieldNum value:value];
208  } else if (dataType == GPBDataTypeFixed64) {
209    [stream writeFixed64:fieldNum value:value];
210  } else {
211    NSCAssert(NO, @"Unexpected type %d", dataType);
212  }
213}
214
215static size_t ComputeDictBoolFieldSize(BOOL value, uint32_t fieldNum, __unused GPBDataType dataType) {
216  NSCAssert(dataType == GPBDataTypeBool, @"bad type: %d", dataType);
217  return GPBComputeBoolSize(fieldNum, value);
218}
219
220static void WriteDictBoolField(GPBCodedOutputStream *stream, BOOL value, uint32_t fieldNum, __unused GPBDataType dataType) {
221  NSCAssert(dataType == GPBDataTypeBool, @"bad type: %d", dataType);
222  [stream writeBool:fieldNum value:value];
223}
224
225static size_t ComputeDictEnumFieldSize(int32_t value, uint32_t fieldNum, __unused GPBDataType dataType) {
226  NSCAssert(dataType == GPBDataTypeEnum, @"bad type: %d", dataType);
227  return GPBComputeEnumSize(fieldNum, value);
228}
229
230static void WriteDictEnumField(GPBCodedOutputStream *stream, int32_t value, uint32_t fieldNum, __unused GPBDataType dataType) {
231  NSCAssert(dataType == GPBDataTypeEnum, @"bad type: %d", dataType);
232  [stream writeEnum:fieldNum value:value];
233}
234
235static size_t ComputeDictFloatFieldSize(float value, uint32_t fieldNum, __unused GPBDataType dataType) {
236  NSCAssert(dataType == GPBDataTypeFloat, @"bad type: %d", dataType);
237  return GPBComputeFloatSize(fieldNum, value);
238}
239
240static void WriteDictFloatField(GPBCodedOutputStream *stream, float value, uint32_t fieldNum, __unused GPBDataType dataType) {
241  NSCAssert(dataType == GPBDataTypeFloat, @"bad type: %d", dataType);
242  [stream writeFloat:fieldNum value:value];
243}
244
245static size_t ComputeDictDoubleFieldSize(double value, uint32_t fieldNum, __unused GPBDataType dataType) {
246  NSCAssert(dataType == GPBDataTypeDouble, @"bad type: %d", dataType);
247  return GPBComputeDoubleSize(fieldNum, value);
248}
249
250static void WriteDictDoubleField(GPBCodedOutputStream *stream, double value, uint32_t fieldNum, __unused GPBDataType dataType) {
251  NSCAssert(dataType == GPBDataTypeDouble, @"bad type: %d", dataType);
252  [stream writeDouble:fieldNum value:value];
253}
254
255static size_t ComputeDictStringFieldSize(NSString *value, uint32_t fieldNum, __unused GPBDataType dataType) {
256  NSCAssert(dataType == GPBDataTypeString, @"bad type: %d", dataType);
257  return GPBComputeStringSize(fieldNum, value);
258}
259
260static void WriteDictStringField(GPBCodedOutputStream *stream, NSString *value, uint32_t fieldNum, __unused GPBDataType dataType) {
261  NSCAssert(dataType == GPBDataTypeString, @"bad type: %d", dataType);
262  [stream writeString:fieldNum value:value];
263}
264
265static size_t ComputeDictObjectFieldSize(id value, uint32_t fieldNum, GPBDataType dataType) {
266  if (dataType == GPBDataTypeMessage) {
267    return GPBComputeMessageSize(fieldNum, value);
268  } else if (dataType == GPBDataTypeString) {
269    return GPBComputeStringSize(fieldNum, value);
270  } else if (dataType == GPBDataTypeBytes) {
271    return GPBComputeBytesSize(fieldNum, value);
272  } else {
273    NSCAssert(NO, @"Unexpected type %d", dataType);
274    return 0;
275  }
276}
277
278static void WriteDictObjectField(GPBCodedOutputStream *stream, id value, uint32_t fieldNum, GPBDataType dataType) {
279  if (dataType == GPBDataTypeMessage) {
280    [stream writeMessage:fieldNum value:value];
281  } else if (dataType == GPBDataTypeString) {
282    [stream writeString:fieldNum value:value];
283  } else if (dataType == GPBDataTypeBytes) {
284    [stream writeBytes:fieldNum value:value];
285  } else {
286    NSCAssert(NO, @"Unexpected type %d", dataType);
287  }
288}
289
290//%PDDM-EXPAND-END SERIALIZE_SUPPORT_HELPERS()
291
292// clang-format on
293
294size_t GPBDictionaryComputeSizeInternalHelper(NSDictionary *dict, GPBFieldDescriptor *field) {
295  GPBDataType mapValueType = GPBGetFieldDataType(field);
296  size_t result = 0;
297  NSString *key;
298  NSEnumerator *keys = [dict keyEnumerator];
299  while ((key = [keys nextObject])) {
300    id obj = dict[key];
301    size_t msgSize = GPBComputeStringSize(kMapKeyFieldNumber, key);
302    msgSize += ComputeDictObjectFieldSize(obj, kMapValueFieldNumber, mapValueType);
303    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
304  }
305  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
306  result += tagSize * dict.count;
307  return result;
308}
309
310void GPBDictionaryWriteToStreamInternalHelper(GPBCodedOutputStream *outputStream,
311                                              NSDictionary *dict, GPBFieldDescriptor *field) {
312  NSCAssert(field.mapKeyDataType == GPBDataTypeString, @"Unexpected key type");
313  GPBDataType mapValueType = GPBGetFieldDataType(field);
314  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
315  NSString *key;
316  NSEnumerator *keys = [dict keyEnumerator];
317  while ((key = [keys nextObject])) {
318    id obj = dict[key];
319    // Write the tag.
320    [outputStream writeInt32NoTag:tag];
321    // Write the size of the message.
322    size_t msgSize = GPBComputeStringSize(kMapKeyFieldNumber, key);
323    msgSize += ComputeDictObjectFieldSize(obj, kMapValueFieldNumber, mapValueType);
324
325    // Write the size and fields.
326    [outputStream writeInt32NoTag:(int32_t)msgSize];
327    [outputStream writeString:kMapKeyFieldNumber value:key];
328    WriteDictObjectField(outputStream, obj, kMapValueFieldNumber, mapValueType);
329  }
330}
331
332BOOL GPBDictionaryIsInitializedInternalHelper(NSDictionary *dict,
333                                              __unused GPBFieldDescriptor *field) {
334  NSCAssert(field.mapKeyDataType == GPBDataTypeString, @"Unexpected key type");
335  NSCAssert(GPBGetFieldDataType(field) == GPBDataTypeMessage, @"Unexpected value type");
336  GPBMessage *msg;
337  NSEnumerator *objects = [dict objectEnumerator];
338  while ((msg = [objects nextObject])) {
339    if (!msg.initialized) {
340      return NO;
341    }
342  }
343  return YES;
344}
345
346// Note: if the type is an object, it the retain pass back to the caller.
347static void ReadValue(GPBCodedInputStream *stream, GPBGenericValue *valueToFill, GPBDataType type,
348                      id<GPBExtensionRegistry> registry, GPBFieldDescriptor *field) {
349  switch (type) {
350    case GPBDataTypeBool:
351      valueToFill->valueBool = GPBCodedInputStreamReadBool(&stream->state_);
352      break;
353    case GPBDataTypeFixed32:
354      valueToFill->valueUInt32 = GPBCodedInputStreamReadFixed32(&stream->state_);
355      break;
356    case GPBDataTypeSFixed32:
357      valueToFill->valueInt32 = GPBCodedInputStreamReadSFixed32(&stream->state_);
358      break;
359    case GPBDataTypeFloat:
360      valueToFill->valueFloat = GPBCodedInputStreamReadFloat(&stream->state_);
361      break;
362    case GPBDataTypeFixed64:
363      valueToFill->valueUInt64 = GPBCodedInputStreamReadFixed64(&stream->state_);
364      break;
365    case GPBDataTypeSFixed64:
366      valueToFill->valueInt64 = GPBCodedInputStreamReadSFixed64(&stream->state_);
367      break;
368    case GPBDataTypeDouble:
369      valueToFill->valueDouble = GPBCodedInputStreamReadDouble(&stream->state_);
370      break;
371    case GPBDataTypeInt32:
372      valueToFill->valueInt32 = GPBCodedInputStreamReadInt32(&stream->state_);
373      break;
374    case GPBDataTypeInt64:
375      valueToFill->valueInt64 = GPBCodedInputStreamReadInt64(&stream->state_);
376      break;
377    case GPBDataTypeSInt32:
378      valueToFill->valueInt32 = GPBCodedInputStreamReadSInt32(&stream->state_);
379      break;
380    case GPBDataTypeSInt64:
381      valueToFill->valueInt64 = GPBCodedInputStreamReadSInt64(&stream->state_);
382      break;
383    case GPBDataTypeUInt32:
384      valueToFill->valueUInt32 = GPBCodedInputStreamReadUInt32(&stream->state_);
385      break;
386    case GPBDataTypeUInt64:
387      valueToFill->valueUInt64 = GPBCodedInputStreamReadUInt64(&stream->state_);
388      break;
389    case GPBDataTypeBytes:
390      [valueToFill->valueData release];
391      valueToFill->valueData = GPBCodedInputStreamReadRetainedBytes(&stream->state_);
392      break;
393    case GPBDataTypeString:
394      [valueToFill->valueString release];
395      valueToFill->valueString = GPBCodedInputStreamReadRetainedString(&stream->state_);
396      break;
397    case GPBDataTypeMessage: {
398      GPBMessage *message = [[field.msgClass alloc] init];
399      [stream readMessage:message extensionRegistry:registry];
400      [valueToFill->valueMessage release];
401      valueToFill->valueMessage = message;
402      break;
403    }
404    case GPBDataTypeGroup:
405      NSCAssert(NO, @"Can't happen");
406      break;
407    case GPBDataTypeEnum:
408      valueToFill->valueEnum = GPBCodedInputStreamReadEnum(&stream->state_);
409      break;
410  }
411}
412
413void GPBDictionaryReadEntry(id mapDictionary, GPBCodedInputStream *stream,
414                            id<GPBExtensionRegistry> registry, GPBFieldDescriptor *field,
415                            GPBMessage *parentMessage) {
416  GPBDataType keyDataType = field.mapKeyDataType;
417  GPBDataType valueDataType = GPBGetFieldDataType(field);
418
419  GPBGenericValue key;
420  GPBGenericValue value;
421  // Zero them (but pick up any enum default for proto2).
422  key.valueString = value.valueString = nil;
423  if (valueDataType == GPBDataTypeEnum) {
424    value = field.defaultValue;
425  }
426
427  GPBCodedInputStreamState *state = &stream->state_;
428  uint32_t keyTag = GPBWireFormatMakeTag(kMapKeyFieldNumber, GPBWireFormatForType(keyDataType, NO));
429  uint32_t valueTag =
430      GPBWireFormatMakeTag(kMapValueFieldNumber, GPBWireFormatForType(valueDataType, NO));
431
432  BOOL hitError = NO;
433  while (YES) {
434    uint32_t tag = GPBCodedInputStreamReadTag(state);
435    if (tag == keyTag) {
436      ReadValue(stream, &key, keyDataType, registry, field);
437    } else if (tag == valueTag) {
438      ReadValue(stream, &value, valueDataType, registry, field);
439    } else if (tag == 0) {
440      // zero signals EOF / limit reached
441      break;
442    } else {  // Unknown
443      if (![stream skipField:tag]) {
444        hitError = YES;
445        break;
446      }
447    }
448  }
449
450  if (!hitError) {
451    // Handle the special defaults and/or missing key/value.
452    if ((keyDataType == GPBDataTypeString) && (key.valueString == nil)) {
453      key.valueString = [@"" retain];
454    }
455    if (GPBDataTypeIsObject(valueDataType) && value.valueString == nil) {
456#pragma clang diagnostic push
457#pragma clang diagnostic ignored "-Wswitch-enum"
458      switch (valueDataType) {
459        case GPBDataTypeString:
460          value.valueString = [@"" retain];
461          break;
462        case GPBDataTypeBytes:
463          value.valueData = [GPBEmptyNSData() retain];
464          break;
465#if defined(__clang_analyzer__)
466        case GPBDataTypeGroup:
467          // Maps can't really have Groups as the value type, but this case is needed
468          // so the analyzer won't report the possibility of send nil in for the value
469          // in the NSMutableDictionary case below.
470#endif
471        case GPBDataTypeMessage: {
472          value.valueMessage = [[field.msgClass alloc] init];
473          break;
474        }
475        default:
476          // Nothing
477          break;
478      }
479#pragma clang diagnostic pop
480    }
481
482    if ((keyDataType == GPBDataTypeString) && GPBDataTypeIsObject(valueDataType)) {
483      // mapDictionary is an NSMutableDictionary
484      [(NSMutableDictionary *)mapDictionary setObject:value.valueString forKey:key.valueString];
485    } else {
486      if (valueDataType == GPBDataTypeEnum) {
487        if (!GPBFieldIsClosedEnum(field) || [field isValidEnumValue:value.valueEnum]) {
488          [mapDictionary setGPBGenericValue:&value forGPBGenericValueKey:&key];
489        } else {
490          NSData *data = [mapDictionary serializedDataForUnknownValue:value.valueEnum
491                                                               forKey:&key
492                                                          keyDataType:keyDataType];
493          [parentMessage addUnknownMapEntry:GPBFieldNumber(field) value:data];
494        }
495      } else {
496        [mapDictionary setGPBGenericValue:&value forGPBGenericValueKey:&key];
497      }
498    }
499  }
500
501  if (GPBDataTypeIsObject(keyDataType)) {
502    [key.valueString release];
503  }
504  if (GPBDataTypeIsObject(valueDataType)) {
505    [value.valueString release];
506  }
507}
508
509//
510// Macros for the common basic cases.
511//
512
513// Disable clang-format for the macros.
514// clang-format off
515
516//%PDDM-DEFINE DICTIONARY_IMPL_FOR_POD_KEY(KEY_NAME, KEY_TYPE)
517//%DICTIONARY_POD_IMPL_FOR_KEY(KEY_NAME, KEY_TYPE, , POD)
518//%DICTIONARY_POD_KEY_TO_OBJECT_IMPL(KEY_NAME, KEY_TYPE, Object, id)
519
520//%PDDM-DEFINE DICTIONARY_POD_IMPL_FOR_KEY(KEY_NAME, KEY_TYPE, KisP, KHELPER)
521//%DICTIONARY_KEY_TO_POD_IMPL(KEY_NAME, KEY_TYPE, KisP, UInt32, uint32_t, KHELPER)
522//%DICTIONARY_KEY_TO_POD_IMPL(KEY_NAME, KEY_TYPE, KisP, Int32, int32_t, KHELPER)
523//%DICTIONARY_KEY_TO_POD_IMPL(KEY_NAME, KEY_TYPE, KisP, UInt64, uint64_t, KHELPER)
524//%DICTIONARY_KEY_TO_POD_IMPL(KEY_NAME, KEY_TYPE, KisP, Int64, int64_t, KHELPER)
525//%DICTIONARY_KEY_TO_POD_IMPL(KEY_NAME, KEY_TYPE, KisP, Bool, BOOL, KHELPER)
526//%DICTIONARY_KEY_TO_POD_IMPL(KEY_NAME, KEY_TYPE, KisP, Float, float, KHELPER)
527//%DICTIONARY_KEY_TO_POD_IMPL(KEY_NAME, KEY_TYPE, KisP, Double, double, KHELPER)
528//%DICTIONARY_KEY_TO_ENUM_IMPL(KEY_NAME, KEY_TYPE, KisP, Enum, int32_t, KHELPER)
529
530//%PDDM-DEFINE DICTIONARY_KEY_TO_POD_IMPL(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER)
531//%DICTIONARY_COMMON_IMPL(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, POD, VALUE_NAME, value)
532
533//%PDDM-DEFINE DICTIONARY_POD_KEY_TO_OBJECT_IMPL(KEY_NAME, KEY_TYPE, VALUE_NAME, VALUE_TYPE)
534//%DICTIONARY_COMMON_IMPL(KEY_NAME, KEY_TYPE, , VALUE_NAME, VALUE_TYPE, POD, OBJECT, Object, object)
535
536//%PDDM-DEFINE DICTIONARY_COMMON_IMPL(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, VNAME, VNAME_VAR)
537//%#pragma mark - KEY_NAME -> VALUE_NAME
538//%
539//%@implementation GPB##KEY_NAME##VALUE_NAME##Dictionary {
540//% @package
541//%  NSMutableDictionary *_dictionary;
542//%}
543//%
544//%- (instancetype)init {
545//%  return [self initWith##VNAME##s:NULL forKeys:NULL count:0];
546//%}
547//%
548//%- (instancetype)initWith##VNAME##s:(const VALUE_TYPE [])##VNAME_VAR##s
549//%                ##VNAME$S##  forKeys:(const KEY_TYPE##KisP$S##KisP [])keys
550//%                ##VNAME$S##    count:(NSUInteger)count {
551//%  self = [super init];
552//%  if (self) {
553//%    _dictionary = [[NSMutableDictionary alloc] init];
554//%    if (count && VNAME_VAR##s && keys) {
555//%      for (NSUInteger i = 0; i < count; ++i) {
556//%DICTIONARY_VALIDATE_VALUE_##VHELPER(VNAME_VAR##s[i], ______)##DICTIONARY_VALIDATE_KEY_##KHELPER(keys[i], ______)        [_dictionary setObject:WRAPPED##VHELPER(VNAME_VAR##s[i]) forKey:WRAPPED##KHELPER(keys[i])];
557//%      }
558//%    }
559//%  }
560//%  return self;
561//%}
562//%
563//%- (instancetype)initWithDictionary:(GPB##KEY_NAME##VALUE_NAME##Dictionary *)dictionary {
564//%  self = [self initWith##VNAME##s:NULL forKeys:NULL count:0];
565//%  if (self) {
566//%    if (dictionary) {
567//%      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
568//%    }
569//%  }
570//%  return self;
571//%}
572//%
573//%- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
574//%  return [self initWith##VNAME##s:NULL forKeys:NULL count:0];
575//%}
576//%
577//%DICTIONARY_IMMUTABLE_CORE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, VNAME, VNAME_VAR, )
578//%
579//%VALUE_FOR_KEY_##VHELPER(KEY_TYPE##KisP$S##KisP, VALUE_NAME, VALUE_TYPE, KHELPER)
580//%
581//%DICTIONARY_MUTABLE_CORE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, VNAME, VNAME_VAR, )
582//%
583//%@end
584//%
585
586//%PDDM-DEFINE DICTIONARY_KEY_TO_ENUM_IMPL(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER)
587//%DICTIONARY_KEY_TO_ENUM_IMPL2(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, POD)
588//%PDDM-DEFINE DICTIONARY_KEY_TO_ENUM_IMPL2(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER)
589//%#pragma mark - KEY_NAME -> VALUE_NAME
590//%
591//%@implementation GPB##KEY_NAME##VALUE_NAME##Dictionary {
592//% @package
593//%  NSMutableDictionary *_dictionary;
594//%  GPBEnumValidationFunc _validationFunc;
595//%}
596//%
597//%@synthesize validationFunc = _validationFunc;
598//%
599//%- (instancetype)init {
600//%  return [self initWithValidationFunction:NULL rawValues:NULL forKeys:NULL count:0];
601//%}
602//%
603//%- (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func {
604//%  return [self initWithValidationFunction:func rawValues:NULL forKeys:NULL count:0];
605//%}
606//%
607//%- (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func
608//%                                 rawValues:(const VALUE_TYPE [])rawValues
609//%                                   forKeys:(const KEY_TYPE##KisP$S##KisP [])keys
610//%                                     count:(NSUInteger)count {
611//%  self = [super init];
612//%  if (self) {
613//%    _dictionary = [[NSMutableDictionary alloc] init];
614//%    _validationFunc = (func != NULL ? func : DictDefault_IsValidValue);
615//%    if (count && rawValues && keys) {
616//%      for (NSUInteger i = 0; i < count; ++i) {
617//%DICTIONARY_VALIDATE_KEY_##KHELPER(keys[i], ______)        [_dictionary setObject:WRAPPED##VHELPER(rawValues[i]) forKey:WRAPPED##KHELPER(keys[i])];
618//%      }
619//%    }
620//%  }
621//%  return self;
622//%}
623//%
624//%- (instancetype)initWithDictionary:(GPB##KEY_NAME##VALUE_NAME##Dictionary *)dictionary {
625//%  self = [self initWithValidationFunction:dictionary.validationFunc
626//%                                rawValues:NULL
627//%                                  forKeys:NULL
628//%                                    count:0];
629//%  if (self) {
630//%    if (dictionary) {
631//%      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
632//%    }
633//%  }
634//%  return self;
635//%}
636//%
637//%- (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func
638//%                                  capacity:(__unused NSUInteger)numItems {
639//%  return [self initWithValidationFunction:func rawValues:NULL forKeys:NULL count:0];
640//%}
641//%
642//%DICTIONARY_IMMUTABLE_CORE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, Value, value, Raw)
643//%
644//%- (BOOL)getEnum:(VALUE_TYPE *)value forKey:(KEY_TYPE##KisP$S##KisP)key {
645//%  NSNumber *wrapped = [_dictionary objectForKey:WRAPPED##KHELPER(key)];
646//%  if (wrapped && value) {
647//%    VALUE_TYPE result = UNWRAP##VALUE_NAME(wrapped);
648//%    if (!_validationFunc(result)) {
649//%      result = kGPBUnrecognizedEnumeratorValue;
650//%    }
651//%    *value = result;
652//%  }
653//%  return (wrapped != NULL);
654//%}
655//%
656//%- (BOOL)getRawValue:(VALUE_TYPE *)rawValue forKey:(KEY_TYPE##KisP$S##KisP)key {
657//%  NSNumber *wrapped = [_dictionary objectForKey:WRAPPED##KHELPER(key)];
658//%  if (wrapped && rawValue) {
659//%    *rawValue = UNWRAP##VALUE_NAME(wrapped);
660//%  }
661//%  return (wrapped != NULL);
662//%}
663//%
664//%- (void)enumerateKeysAndEnumsUsingBlock:
665//%    (void (NS_NOESCAPE ^)(KEY_TYPE KisP##key, VALUE_TYPE value, BOOL *stop))block {
666//%  GPBEnumValidationFunc func = _validationFunc;
667//%  BOOL stop = NO;
668//%  NSEnumerator *keys = [_dictionary keyEnumerator];
669//%  ENUM_TYPE##KHELPER(KEY_TYPE)##aKey;
670//%  while ((aKey = [keys nextObject])) {
671//%    ENUM_TYPE##VHELPER(VALUE_TYPE)##aValue = _dictionary[aKey];
672//%      VALUE_TYPE unwrapped = UNWRAP##VALUE_NAME(aValue);
673//%      if (!func(unwrapped)) {
674//%        unwrapped = kGPBUnrecognizedEnumeratorValue;
675//%      }
676//%    block(UNWRAP##KEY_NAME(aKey), unwrapped, &stop);
677//%    if (stop) {
678//%      break;
679//%    }
680//%  }
681//%}
682//%
683//%DICTIONARY_MUTABLE_CORE2(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, Value, Enum, value, Raw)
684//%
685//%- (void)setEnum:(VALUE_TYPE)value forKey:(KEY_TYPE##KisP$S##KisP)key {
686//%DICTIONARY_VALIDATE_KEY_##KHELPER(key, )  if (!_validationFunc(value)) {
687//%    [NSException raise:NSInvalidArgumentException
688//%                format:@"GPB##KEY_NAME##VALUE_NAME##Dictionary: Attempt to set an unknown enum value (%d)",
689//%                       value];
690//%  }
691//%
692//%  [_dictionary setObject:WRAPPED##VHELPER(value) forKey:WRAPPED##KHELPER(key)];
693//%  if (_autocreator) {
694//%    GPBAutocreatedDictionaryModified(_autocreator, self);
695//%  }
696//%}
697//%
698//%@end
699//%
700
701//%PDDM-DEFINE DICTIONARY_IMMUTABLE_CORE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, VNAME, VNAME_VAR, ACCESSOR_NAME)
702//%- (void)dealloc {
703//%  NSAssert(!_autocreator,
704//%           @"%@: Autocreator must be cleared before release, autocreator: %@",
705//%           [self class], _autocreator);
706//%  [_dictionary release];
707//%  [super dealloc];
708//%}
709//%
710//%- (instancetype)copyWithZone:(NSZone *)zone {
711//%  return [[GPB##KEY_NAME##VALUE_NAME##Dictionary allocWithZone:zone] initWithDictionary:self];
712//%}
713//%
714//%- (BOOL)isEqual:(id)other {
715//%  if (self == other) {
716//%    return YES;
717//%  }
718//%  if (![other isKindOfClass:[GPB##KEY_NAME##VALUE_NAME##Dictionary class]]) {
719//%    return NO;
720//%  }
721//%  GPB##KEY_NAME##VALUE_NAME##Dictionary *otherDictionary = other;
722//%  return [_dictionary isEqual:otherDictionary->_dictionary];
723//%}
724//%
725//%- (NSUInteger)hash {
726//%  return _dictionary.count;
727//%}
728//%
729//%- (NSString *)description {
730//%  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
731//%}
732//%
733//%- (NSUInteger)count {
734//%  return _dictionary.count;
735//%}
736//%
737//%- (void)enumerateKeysAnd##ACCESSOR_NAME##VNAME##sUsingBlock:
738//%    (void (NS_NOESCAPE ^)(KEY_TYPE KisP##key, VALUE_TYPE VNAME_VAR, BOOL *stop))block {
739//%  BOOL stop = NO;
740//%  NSDictionary *internal = _dictionary;
741//%  NSEnumerator *keys = [internal keyEnumerator];
742//%  ENUM_TYPE##KHELPER(KEY_TYPE)##aKey;
743//%  while ((aKey = [keys nextObject])) {
744//%    ENUM_TYPE##VHELPER(VALUE_TYPE)##a##VNAME_VAR$u = internal[aKey];
745//%    block(UNWRAP##KEY_NAME(aKey), UNWRAP##VALUE_NAME(a##VNAME_VAR$u), &stop);
746//%    if (stop) {
747//%      break;
748//%    }
749//%  }
750//%}
751//%
752//%EXTRA_METHODS_##VHELPER(KEY_NAME, VALUE_NAME)- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
753//%  NSDictionary *internal = _dictionary;
754//%  NSUInteger count = internal.count;
755//%  if (count == 0) {
756//%    return 0;
757//%  }
758//%
759//%  GPBDataType valueDataType = GPBGetFieldDataType(field);
760//%  GPBDataType keyDataType = field.mapKeyDataType;
761//%  size_t result = 0;
762//%  NSEnumerator *keys = [internal keyEnumerator];
763//%  ENUM_TYPE##KHELPER(KEY_TYPE)##aKey;
764//%  while ((aKey = [keys nextObject])) {
765//%    ENUM_TYPE##VHELPER(VALUE_TYPE)##a##VNAME_VAR$u = internal[aKey];
766//%    size_t msgSize = ComputeDict##KEY_NAME##FieldSize(UNWRAP##KEY_NAME(aKey), kMapKeyFieldNumber, keyDataType);
767//%    msgSize += ComputeDict##VALUE_NAME##FieldSize(UNWRAP##VALUE_NAME(a##VNAME_VAR$u), kMapValueFieldNumber, valueDataType);
768//%    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
769//%  }
770//%  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
771//%  result += tagSize * count;
772//%  return result;
773//%}
774//%
775//%- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
776//%                         asField:(GPBFieldDescriptor *)field {
777//%  GPBDataType valueDataType = GPBGetFieldDataType(field);
778//%  GPBDataType keyDataType = field.mapKeyDataType;
779//%  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
780//%  NSDictionary *internal = _dictionary;
781//%  NSEnumerator *keys = [internal keyEnumerator];
782//%  ENUM_TYPE##KHELPER(KEY_TYPE)##aKey;
783//%  while ((aKey = [keys nextObject])) {
784//%    ENUM_TYPE##VHELPER(VALUE_TYPE)##a##VNAME_VAR$u = internal[aKey];
785//%    [outputStream writeInt32NoTag:tag];
786//%    // Write the size of the message.
787//%    KEY_TYPE KisP##unwrappedKey = UNWRAP##KEY_NAME(aKey);
788//%    VALUE_TYPE unwrappedValue = UNWRAP##VALUE_NAME(a##VNAME_VAR$u);
789//%    size_t msgSize = ComputeDict##KEY_NAME##FieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
790//%    msgSize += ComputeDict##VALUE_NAME##FieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
791//%    [outputStream writeInt32NoTag:(int32_t)msgSize];
792//%    // Write the fields.
793//%    WriteDict##KEY_NAME##Field(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
794//%    WriteDict##VALUE_NAME##Field(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
795//%  }
796//%}
797//%
798//%SERIAL_DATA_FOR_ENTRY_##VHELPER(KEY_NAME, VALUE_NAME)- (void)setGPBGenericValue:(GPBGenericValue *)value
799//%     forGPBGenericValueKey:(GPBGenericValue *)key {
800//%  [_dictionary setObject:WRAPPED##VHELPER(value->##GPBVALUE_##VHELPER(VALUE_NAME)##) forKey:WRAPPED##KHELPER(key->value##KEY_NAME)];
801//%}
802//%
803//%- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
804//%  [self enumerateKeysAnd##ACCESSOR_NAME##VNAME##sUsingBlock:^(KEY_TYPE KisP##key, VALUE_TYPE VNAME_VAR, __unused BOOL *stop) {
805//%      block(TEXT_FORMAT_OBJ##KEY_NAME(key), TEXT_FORMAT_OBJ##VALUE_NAME(VNAME_VAR));
806//%  }];
807//%}
808//%PDDM-DEFINE DICTIONARY_MUTABLE_CORE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, VNAME, VNAME_VAR, ACCESSOR_NAME)
809//%DICTIONARY_MUTABLE_CORE2(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, VNAME, VNAME, VNAME_VAR, ACCESSOR_NAME)
810//%PDDM-DEFINE DICTIONARY_MUTABLE_CORE2(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, VNAME, VNAME_REMOVE, VNAME_VAR, ACCESSOR_NAME)
811//%- (void)add##ACCESSOR_NAME##EntriesFromDictionary:(GPB##KEY_NAME##VALUE_NAME##Dictionary *)otherDictionary {
812//%  if (otherDictionary) {
813//%    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
814//%    if (_autocreator) {
815//%      GPBAutocreatedDictionaryModified(_autocreator, self);
816//%    }
817//%  }
818//%}
819//%
820//%- (void)set##ACCESSOR_NAME##VNAME##:(VALUE_TYPE)VNAME_VAR forKey:(KEY_TYPE##KisP$S##KisP)key {
821//%DICTIONARY_VALIDATE_VALUE_##VHELPER(VNAME_VAR, )##DICTIONARY_VALIDATE_KEY_##KHELPER(key, )  [_dictionary setObject:WRAPPED##VHELPER(VNAME_VAR) forKey:WRAPPED##KHELPER(key)];
822//%  if (_autocreator) {
823//%    GPBAutocreatedDictionaryModified(_autocreator, self);
824//%  }
825//%}
826//%
827//%- (void)remove##VNAME_REMOVE##ForKey:(KEY_TYPE##KisP$S##KisP)aKey {
828//%  [_dictionary removeObjectForKey:WRAPPED##KHELPER(aKey)];
829//%}
830//%
831//%- (void)removeAll {
832//%  [_dictionary removeAllObjects];
833//%}
834
835//
836// Custom Generation for Bool keys
837//
838
839//%PDDM-DEFINE DICTIONARY_BOOL_KEY_TO_POD_IMPL(VALUE_NAME, VALUE_TYPE)
840//%DICTIONARY_BOOL_KEY_TO_VALUE_IMPL(VALUE_NAME, VALUE_TYPE, POD, VALUE_NAME, value)
841//%PDDM-DEFINE DICTIONARY_BOOL_KEY_TO_OBJECT_IMPL(VALUE_NAME, VALUE_TYPE)
842//%DICTIONARY_BOOL_KEY_TO_VALUE_IMPL(VALUE_NAME, VALUE_TYPE, OBJECT, Object, object)
843
844//%PDDM-DEFINE DICTIONARY_BOOL_KEY_TO_VALUE_IMPL(VALUE_NAME, VALUE_TYPE, HELPER, VNAME, VNAME_VAR)
845//%#pragma mark - Bool -> VALUE_NAME
846//%
847//%@implementation GPBBool##VALUE_NAME##Dictionary {
848//% @package
849//%  VALUE_TYPE _values[2];
850//%BOOL_DICT_HAS_STORAGE_##HELPER()}
851//%
852//%- (instancetype)init {
853//%  return [self initWith##VNAME##s:NULL forKeys:NULL count:0];
854//%}
855//%
856//%BOOL_DICT_INITS_##HELPER(VALUE_NAME, VALUE_TYPE)
857//%
858//%- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
859//%  return [self initWith##VNAME##s:NULL forKeys:NULL count:0];
860//%}
861//%
862//%BOOL_DICT_DEALLOC##HELPER()
863//%
864//%- (instancetype)copyWithZone:(NSZone *)zone {
865//%  return [[GPBBool##VALUE_NAME##Dictionary allocWithZone:zone] initWithDictionary:self];
866//%}
867//%
868//%- (BOOL)isEqual:(id)other {
869//%  if (self == other) {
870//%    return YES;
871//%  }
872//%  if (![other isKindOfClass:[GPBBool##VALUE_NAME##Dictionary class]]) {
873//%    return NO;
874//%  }
875//%  GPBBool##VALUE_NAME##Dictionary *otherDictionary = other;
876//%  if ((BOOL_DICT_W_HAS##HELPER(0, ) != BOOL_DICT_W_HAS##HELPER(0, otherDictionary->)) ||
877//%      (BOOL_DICT_W_HAS##HELPER(1, ) != BOOL_DICT_W_HAS##HELPER(1, otherDictionary->))) {
878//%    return NO;
879//%  }
880//%  if ((BOOL_DICT_W_HAS##HELPER(0, ) && (NEQ_##HELPER(_values[0], otherDictionary->_values[0]))) ||
881//%      (BOOL_DICT_W_HAS##HELPER(1, ) && (NEQ_##HELPER(_values[1], otherDictionary->_values[1])))) {
882//%    return NO;
883//%  }
884//%  return YES;
885//%}
886//%
887//%- (NSUInteger)hash {
888//%  return (BOOL_DICT_W_HAS##HELPER(0, ) ? 1 : 0) + (BOOL_DICT_W_HAS##HELPER(1, ) ? 1 : 0);
889//%}
890//%
891//%- (NSString *)description {
892//%  NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> {", [self class], self];
893//%  if (BOOL_DICT_W_HAS##HELPER(0, )) {
894//%    [result appendFormat:@"NO: STR_FORMAT_##HELPER(VALUE_NAME)", _values[0]];
895//%  }
896//%  if (BOOL_DICT_W_HAS##HELPER(1, )) {
897//%    [result appendFormat:@"YES: STR_FORMAT_##HELPER(VALUE_NAME)", _values[1]];
898//%  }
899//%  [result appendString:@" }"];
900//%  return result;
901//%}
902//%
903//%- (NSUInteger)count {
904//%  return (BOOL_DICT_W_HAS##HELPER(0, ) ? 1 : 0) + (BOOL_DICT_W_HAS##HELPER(1, ) ? 1 : 0);
905//%}
906//%
907//%BOOL_VALUE_FOR_KEY_##HELPER(VALUE_NAME, VALUE_TYPE)
908//%
909//%BOOL_SET_GPBVALUE_FOR_KEY_##HELPER(VALUE_NAME, VALUE_TYPE, VisP)
910//%
911//%- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
912//%  if (BOOL_DICT_HAS##HELPER(0, )) {
913//%    block(@"false", TEXT_FORMAT_OBJ##VALUE_NAME(_values[0]));
914//%  }
915//%  if (BOOL_DICT_W_HAS##HELPER(1, )) {
916//%    block(@"true", TEXT_FORMAT_OBJ##VALUE_NAME(_values[1]));
917//%  }
918//%}
919//%
920//%- (void)enumerateKeysAnd##VNAME##sUsingBlock:
921//%    (void (NS_NOESCAPE ^)(BOOL key, VALUE_TYPE VNAME_VAR, BOOL *stop))block {
922//%  BOOL stop = NO;
923//%  if (BOOL_DICT_HAS##HELPER(0, )) {
924//%    block(NO, _values[0], &stop);
925//%  }
926//%  if (!stop && BOOL_DICT_W_HAS##HELPER(1, )) {
927//%    block(YES, _values[1], &stop);
928//%  }
929//%}
930//%
931//%BOOL_EXTRA_METHODS_##HELPER(Bool, VALUE_NAME)- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
932//%  GPBDataType valueDataType = GPBGetFieldDataType(field);
933//%  NSUInteger count = 0;
934//%  size_t result = 0;
935//%  for (int i = 0; i < 2; ++i) {
936//%    if (BOOL_DICT_HAS##HELPER(i, )) {
937//%      ++count;
938//%      size_t msgSize = ComputeDictBoolFieldSize((i == 1), kMapKeyFieldNumber, GPBDataTypeBool);
939//%      msgSize += ComputeDict##VALUE_NAME##FieldSize(_values[i], kMapValueFieldNumber, valueDataType);
940//%      result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
941//%    }
942//%  }
943//%  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
944//%  result += tagSize * count;
945//%  return result;
946//%}
947//%
948//%- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
949//%                         asField:(GPBFieldDescriptor *)field {
950//%  GPBDataType valueDataType = GPBGetFieldDataType(field);
951//%  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
952//%  for (int i = 0; i < 2; ++i) {
953//%    if (BOOL_DICT_HAS##HELPER(i, )) {
954//%      // Write the tag.
955//%      [outputStream writeInt32NoTag:tag];
956//%      // Write the size of the message.
957//%      size_t msgSize = ComputeDictBoolFieldSize((i == 1), kMapKeyFieldNumber, GPBDataTypeBool);
958//%      msgSize += ComputeDict##VALUE_NAME##FieldSize(_values[i], kMapValueFieldNumber, valueDataType);
959//%      [outputStream writeInt32NoTag:(int32_t)msgSize];
960//%      // Write the fields.
961//%      WriteDictBoolField(outputStream, (i == 1), kMapKeyFieldNumber, GPBDataTypeBool);
962//%      WriteDict##VALUE_NAME##Field(outputStream, _values[i], kMapValueFieldNumber, valueDataType);
963//%    }
964//%  }
965//%}
966//%
967//%BOOL_DICT_MUTATIONS_##HELPER(VALUE_NAME, VALUE_TYPE)
968//%
969//%@end
970//%
971
972
973//
974// Helpers for PODs
975//
976
977//%PDDM-DEFINE VALUE_FOR_KEY_POD(KEY_TYPE, VALUE_NAME, VALUE_TYPE, KHELPER)
978//%- (BOOL)get##VALUE_NAME##:(nullable VALUE_TYPE *)value forKey:(KEY_TYPE)key {
979//%  NSNumber *wrapped = [_dictionary objectForKey:WRAPPED##KHELPER(key)];
980//%  if (wrapped && value) {
981//%    *value = UNWRAP##VALUE_NAME(wrapped);
982//%  }
983//%  return (wrapped != NULL);
984//%}
985//%PDDM-DEFINE WRAPPEDPOD(VALUE)
986//%@(VALUE)
987//%PDDM-DEFINE UNWRAPUInt32(VALUE)
988//%[VALUE unsignedIntValue]
989//%PDDM-DEFINE UNWRAPInt32(VALUE)
990//%[VALUE intValue]
991//%PDDM-DEFINE UNWRAPUInt64(VALUE)
992//%[VALUE unsignedLongLongValue]
993//%PDDM-DEFINE UNWRAPInt64(VALUE)
994//%[VALUE longLongValue]
995//%PDDM-DEFINE UNWRAPBool(VALUE)
996//%[VALUE boolValue]
997//%PDDM-DEFINE UNWRAPFloat(VALUE)
998//%[VALUE floatValue]
999//%PDDM-DEFINE UNWRAPDouble(VALUE)
1000//%[VALUE doubleValue]
1001//%PDDM-DEFINE UNWRAPEnum(VALUE)
1002//%[VALUE intValue]
1003//%PDDM-DEFINE TEXT_FORMAT_OBJUInt32(VALUE)
1004//%[NSString stringWithFormat:@"%u", VALUE]
1005//%PDDM-DEFINE TEXT_FORMAT_OBJInt32(VALUE)
1006//%[NSString stringWithFormat:@"%d", VALUE]
1007//%PDDM-DEFINE TEXT_FORMAT_OBJUInt64(VALUE)
1008//%[NSString stringWithFormat:@"%llu", VALUE]
1009//%PDDM-DEFINE TEXT_FORMAT_OBJInt64(VALUE)
1010//%[NSString stringWithFormat:@"%lld", VALUE]
1011//%PDDM-DEFINE TEXT_FORMAT_OBJBool(VALUE)
1012//%(VALUE ? @"true" : @"false")
1013//%PDDM-DEFINE TEXT_FORMAT_OBJFloat(VALUE)
1014//%[NSString stringWithFormat:@"%.*g", FLT_DIG, VALUE]
1015//%PDDM-DEFINE TEXT_FORMAT_OBJDouble(VALUE)
1016//%[NSString stringWithFormat:@"%.*lg", DBL_DIG, VALUE]
1017//%PDDM-DEFINE TEXT_FORMAT_OBJEnum(VALUE)
1018//%@(VALUE)
1019//%PDDM-DEFINE ENUM_TYPEPOD(TYPE)
1020//%NSNumber *
1021//%PDDM-DEFINE NEQ_POD(VAL1, VAL2)
1022//%VAL1 != VAL2
1023//%PDDM-DEFINE EXTRA_METHODS_POD(KEY_NAME, VALUE_NAME)
1024// Empty
1025//%PDDM-DEFINE BOOL_EXTRA_METHODS_POD(KEY_NAME, VALUE_NAME)
1026// Empty
1027//%PDDM-DEFINE SERIAL_DATA_FOR_ENTRY_POD(KEY_NAME, VALUE_NAME)
1028//%SERIAL_DATA_FOR_ENTRY_POD_##VALUE_NAME(KEY_NAME)
1029//%PDDM-DEFINE SERIAL_DATA_FOR_ENTRY_POD_UInt32(KEY_NAME)
1030// Empty
1031//%PDDM-DEFINE SERIAL_DATA_FOR_ENTRY_POD_Int32(KEY_NAME)
1032// Empty
1033//%PDDM-DEFINE SERIAL_DATA_FOR_ENTRY_POD_UInt64(KEY_NAME)
1034// Empty
1035//%PDDM-DEFINE SERIAL_DATA_FOR_ENTRY_POD_Int64(KEY_NAME)
1036// Empty
1037//%PDDM-DEFINE SERIAL_DATA_FOR_ENTRY_POD_Bool(KEY_NAME)
1038// Empty
1039//%PDDM-DEFINE SERIAL_DATA_FOR_ENTRY_POD_Float(KEY_NAME)
1040// Empty
1041//%PDDM-DEFINE SERIAL_DATA_FOR_ENTRY_POD_Double(KEY_NAME)
1042// Empty
1043//%PDDM-DEFINE SERIAL_DATA_FOR_ENTRY_POD_Enum(KEY_NAME)
1044//%- (NSData *)serializedDataForUnknownValue:(int32_t)value
1045//%                                   forKey:(GPBGenericValue *)key
1046//%                              keyDataType:(GPBDataType)keyDataType {
1047//%  size_t msgSize = ComputeDict##KEY_NAME##FieldSize(key->value##KEY_NAME, kMapKeyFieldNumber, keyDataType);
1048//%  msgSize += ComputeDictEnumFieldSize(value, kMapValueFieldNumber, GPBDataTypeEnum);
1049//%  NSMutableData *data = [NSMutableData dataWithLength:msgSize];
1050//%  GPBCodedOutputStream *outputStream = [[GPBCodedOutputStream alloc] initWithData:data];
1051//%  WriteDict##KEY_NAME##Field(outputStream, key->value##KEY_NAME, kMapKeyFieldNumber, keyDataType);
1052//%  WriteDictEnumField(outputStream, value, kMapValueFieldNumber, GPBDataTypeEnum);
1053//%  [outputStream flush];
1054//%  [outputStream release];
1055//%  return data;
1056//%}
1057//%
1058//%PDDM-DEFINE GPBVALUE_POD(VALUE_NAME)
1059//%value##VALUE_NAME
1060//%PDDM-DEFINE DICTIONARY_VALIDATE_VALUE_POD(VALUE_NAME, EXTRA_INDENT)
1061// Empty
1062//%PDDM-DEFINE DICTIONARY_VALIDATE_KEY_POD(KEY_NAME, EXTRA_INDENT)
1063// Empty
1064
1065//%PDDM-DEFINE BOOL_DICT_HAS_STORAGE_POD()
1066//%  BOOL _valueSet[2];
1067//%
1068//%PDDM-DEFINE BOOL_DICT_INITS_POD(VALUE_NAME, VALUE_TYPE)
1069//%- (instancetype)initWith##VALUE_NAME##s:(const VALUE_TYPE [])values
1070//%                 ##VALUE_NAME$S## forKeys:(const BOOL [])keys
1071//%                 ##VALUE_NAME$S##   count:(NSUInteger)count {
1072//%  self = [super init];
1073//%  if (self) {
1074//%    for (NSUInteger i = 0; i < count; ++i) {
1075//%      int idx = keys[i] ? 1 : 0;
1076//%      _values[idx] = values[i];
1077//%      _valueSet[idx] = YES;
1078//%    }
1079//%  }
1080//%  return self;
1081//%}
1082//%
1083//%- (instancetype)initWithDictionary:(GPBBool##VALUE_NAME##Dictionary *)dictionary {
1084//%  self = [self initWith##VALUE_NAME##s:NULL forKeys:NULL count:0];
1085//%  if (self) {
1086//%    if (dictionary) {
1087//%      for (int i = 0; i < 2; ++i) {
1088//%        if (dictionary->_valueSet[i]) {
1089//%          _values[i] = dictionary->_values[i];
1090//%          _valueSet[i] = YES;
1091//%        }
1092//%      }
1093//%    }
1094//%  }
1095//%  return self;
1096//%}
1097//%PDDM-DEFINE BOOL_DICT_DEALLOCPOD()
1098//%#if !defined(NS_BLOCK_ASSERTIONS)
1099//%- (void)dealloc {
1100//%  NSAssert(!_autocreator,
1101//%           @"%@: Autocreator must be cleared before release, autocreator: %@",
1102//%           [self class], _autocreator);
1103//%  [super dealloc];
1104//%}
1105//%#endif  // !defined(NS_BLOCK_ASSERTIONS)
1106//%PDDM-DEFINE BOOL_DICT_W_HASPOD(IDX, REF)
1107//%BOOL_DICT_HASPOD(IDX, REF)
1108//%PDDM-DEFINE BOOL_DICT_HASPOD(IDX, REF)
1109//%REF##_valueSet[IDX]
1110//%PDDM-DEFINE BOOL_VALUE_FOR_KEY_POD(VALUE_NAME, VALUE_TYPE)
1111//%- (BOOL)get##VALUE_NAME##:(VALUE_TYPE *)value forKey:(BOOL)key {
1112//%  int idx = (key ? 1 : 0);
1113//%  if (_valueSet[idx]) {
1114//%    if (value) {
1115//%      *value = _values[idx];
1116//%    }
1117//%    return YES;
1118//%  }
1119//%  return NO;
1120//%}
1121//%PDDM-DEFINE BOOL_SET_GPBVALUE_FOR_KEY_POD(VALUE_NAME, VALUE_TYPE, VisP)
1122//%- (void)setGPBGenericValue:(GPBGenericValue *)value
1123//%     forGPBGenericValueKey:(GPBGenericValue *)key {
1124//%  int idx = (key->valueBool ? 1 : 0);
1125//%  _values[idx] = value->value##VALUE_NAME;
1126//%  _valueSet[idx] = YES;
1127//%}
1128//%PDDM-DEFINE BOOL_DICT_MUTATIONS_POD(VALUE_NAME, VALUE_TYPE)
1129//%- (void)addEntriesFromDictionary:(GPBBool##VALUE_NAME##Dictionary *)otherDictionary {
1130//%  if (otherDictionary) {
1131//%    for (int i = 0; i < 2; ++i) {
1132//%      if (otherDictionary->_valueSet[i]) {
1133//%        _valueSet[i] = YES;
1134//%        _values[i] = otherDictionary->_values[i];
1135//%      }
1136//%    }
1137//%    if (_autocreator) {
1138//%      GPBAutocreatedDictionaryModified(_autocreator, self);
1139//%    }
1140//%  }
1141//%}
1142//%
1143//%- (void)set##VALUE_NAME:(VALUE_TYPE)value forKey:(BOOL)key {
1144//%  int idx = (key ? 1 : 0);
1145//%  _values[idx] = value;
1146//%  _valueSet[idx] = YES;
1147//%  if (_autocreator) {
1148//%    GPBAutocreatedDictionaryModified(_autocreator, self);
1149//%  }
1150//%}
1151//%
1152//%- (void)remove##VALUE_NAME##ForKey:(BOOL)aKey {
1153//%  _valueSet[aKey ? 1 : 0] = NO;
1154//%}
1155//%
1156//%- (void)removeAll {
1157//%  _valueSet[0] = NO;
1158//%  _valueSet[1] = NO;
1159//%}
1160//%PDDM-DEFINE STR_FORMAT_POD(VALUE_NAME)
1161//%STR_FORMAT_##VALUE_NAME()
1162//%PDDM-DEFINE STR_FORMAT_UInt32()
1163//%%u
1164//%PDDM-DEFINE STR_FORMAT_Int32()
1165//%%d
1166//%PDDM-DEFINE STR_FORMAT_UInt64()
1167//%%llu
1168//%PDDM-DEFINE STR_FORMAT_Int64()
1169//%%lld
1170//%PDDM-DEFINE STR_FORMAT_Bool()
1171//%%d
1172//%PDDM-DEFINE STR_FORMAT_Float()
1173//%%f
1174//%PDDM-DEFINE STR_FORMAT_Double()
1175//%%lf
1176
1177//
1178// Helpers for Objects
1179//
1180
1181//%PDDM-DEFINE VALUE_FOR_KEY_OBJECT(KEY_TYPE, VALUE_NAME, VALUE_TYPE, KHELPER)
1182//%- (VALUE_TYPE)objectForKey:(KEY_TYPE)key {
1183//%  VALUE_TYPE result = [_dictionary objectForKey:WRAPPED##KHELPER(key)];
1184//%  return result;
1185//%}
1186//%PDDM-DEFINE WRAPPEDOBJECT(VALUE)
1187//%VALUE
1188//%PDDM-DEFINE UNWRAPString(VALUE)
1189//%VALUE
1190//%PDDM-DEFINE UNWRAPObject(VALUE)
1191//%VALUE
1192//%PDDM-DEFINE TEXT_FORMAT_OBJString(VALUE)
1193//%VALUE
1194//%PDDM-DEFINE TEXT_FORMAT_OBJObject(VALUE)
1195//%VALUE
1196//%PDDM-DEFINE ENUM_TYPEOBJECT(TYPE)
1197//%ENUM_TYPEOBJECT_##TYPE()
1198//%PDDM-DEFINE ENUM_TYPEOBJECT_NSString()
1199//%NSString *
1200//%PDDM-DEFINE ENUM_TYPEOBJECT_id()
1201//%id ##
1202//%PDDM-DEFINE NEQ_OBJECT(VAL1, VAL2)
1203//%![VAL1 isEqual:VAL2]
1204//%PDDM-DEFINE EXTRA_METHODS_OBJECT(KEY_NAME, VALUE_NAME)
1205//%- (BOOL)isInitialized {
1206//%  for (GPBMessage *msg in [_dictionary objectEnumerator]) {
1207//%    if (!msg.initialized) {
1208//%      return NO;
1209//%    }
1210//%  }
1211//%  return YES;
1212//%}
1213//%
1214//%- (instancetype)deepCopyWithZone:(NSZone *)zone {
1215//%  GPB##KEY_NAME##VALUE_NAME##Dictionary *newDict =
1216//%      [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] init];
1217//%  NSEnumerator *keys = [_dictionary keyEnumerator];
1218//%  id aKey;
1219//%  NSMutableDictionary *internalDict = newDict->_dictionary;
1220//%  while ((aKey = [keys nextObject])) {
1221//%    GPBMessage *msg = _dictionary[aKey];
1222//%    GPBMessage *copiedMsg = [msg copyWithZone:zone];
1223//%    [internalDict setObject:copiedMsg forKey:aKey];
1224//%    [copiedMsg release];
1225//%  }
1226//%  return newDict;
1227//%}
1228//%
1229//%
1230//%PDDM-DEFINE BOOL_EXTRA_METHODS_OBJECT(KEY_NAME, VALUE_NAME)
1231//%- (BOOL)isInitialized {
1232//%  if (_values[0] && ![_values[0] isInitialized]) {
1233//%    return NO;
1234//%  }
1235//%  if (_values[1] && ![_values[1] isInitialized]) {
1236//%    return NO;
1237//%  }
1238//%  return YES;
1239//%}
1240//%
1241//%- (instancetype)deepCopyWithZone:(NSZone *)zone {
1242//%  GPB##KEY_NAME##VALUE_NAME##Dictionary *newDict =
1243//%      [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] init];
1244//%  for (int i = 0; i < 2; ++i) {
1245//%    if (_values[i] != nil) {
1246//%      newDict->_values[i] = [_values[i] copyWithZone:zone];
1247//%    }
1248//%  }
1249//%  return newDict;
1250//%}
1251//%
1252//%
1253//%PDDM-DEFINE SERIAL_DATA_FOR_ENTRY_OBJECT(KEY_NAME, VALUE_NAME)
1254// Empty
1255//%PDDM-DEFINE GPBVALUE_OBJECT(VALUE_NAME)
1256//%valueString
1257//%PDDM-DEFINE DICTIONARY_VALIDATE_VALUE_OBJECT(VALUE_NAME, EXTRA_INDENT)
1258//%##EXTRA_INDENT$S##  if (!##VALUE_NAME) {
1259//%##EXTRA_INDENT$S##    [NSException raise:NSInvalidArgumentException
1260//%##EXTRA_INDENT$S##                format:@"Attempting to add nil object to a Dictionary"];
1261//%##EXTRA_INDENT$S##  }
1262//%
1263//%PDDM-DEFINE DICTIONARY_VALIDATE_KEY_OBJECT(KEY_NAME, EXTRA_INDENT)
1264//%##EXTRA_INDENT$S##  if (!##KEY_NAME) {
1265//%##EXTRA_INDENT$S##    [NSException raise:NSInvalidArgumentException
1266//%##EXTRA_INDENT$S##                format:@"Attempting to add nil key to a Dictionary"];
1267//%##EXTRA_INDENT$S##  }
1268//%
1269
1270//%PDDM-DEFINE BOOL_DICT_HAS_STORAGE_OBJECT()
1271// Empty
1272//%PDDM-DEFINE BOOL_DICT_INITS_OBJECT(VALUE_NAME, VALUE_TYPE)
1273//%- (instancetype)initWithObjects:(const VALUE_TYPE [])objects
1274//%                        forKeys:(const BOOL [])keys
1275//%                          count:(NSUInteger)count {
1276//%  self = [super init];
1277//%  if (self) {
1278//%    for (NSUInteger i = 0; i < count; ++i) {
1279//%      if (!objects[i]) {
1280//%        [NSException raise:NSInvalidArgumentException
1281//%                    format:@"Attempting to add nil object to a Dictionary"];
1282//%      }
1283//%      int idx = keys[i] ? 1 : 0;
1284//%      [_values[idx] release];
1285//%      _values[idx] = (VALUE_TYPE)[objects[i] retain];
1286//%    }
1287//%  }
1288//%  return self;
1289//%}
1290//%
1291//%- (instancetype)initWithDictionary:(GPBBool##VALUE_NAME##Dictionary *)dictionary {
1292//%  self = [self initWithObjects:NULL forKeys:NULL count:0];
1293//%  if (self) {
1294//%    if (dictionary) {
1295//%      _values[0] = [dictionary->_values[0] retain];
1296//%      _values[1] = [dictionary->_values[1] retain];
1297//%    }
1298//%  }
1299//%  return self;
1300//%}
1301//%PDDM-DEFINE BOOL_DICT_DEALLOCOBJECT()
1302//%- (void)dealloc {
1303//%  NSAssert(!_autocreator,
1304//%           @"%@: Autocreator must be cleared before release, autocreator: %@",
1305//%           [self class], _autocreator);
1306//%  [_values[0] release];
1307//%  [_values[1] release];
1308//%  [super dealloc];
1309//%}
1310//%PDDM-DEFINE BOOL_DICT_W_HASOBJECT(IDX, REF)
1311//%(BOOL_DICT_HASOBJECT(IDX, REF))
1312//%PDDM-DEFINE BOOL_DICT_HASOBJECT(IDX, REF)
1313//%REF##_values[IDX] != nil
1314//%PDDM-DEFINE BOOL_VALUE_FOR_KEY_OBJECT(VALUE_NAME, VALUE_TYPE)
1315//%- (VALUE_TYPE)objectForKey:(BOOL)key {
1316//%  return _values[key ? 1 : 0];
1317//%}
1318//%PDDM-DEFINE BOOL_SET_GPBVALUE_FOR_KEY_OBJECT(VALUE_NAME, VALUE_TYPE, VisP)
1319//%- (void)setGPBGenericValue:(GPBGenericValue *)value
1320//%     forGPBGenericValueKey:(GPBGenericValue *)key {
1321//%  int idx = (key->valueBool ? 1 : 0);
1322//%  [_values[idx] release];
1323//%  _values[idx] = [value->valueString retain];
1324//%}
1325
1326//%PDDM-DEFINE BOOL_DICT_MUTATIONS_OBJECT(VALUE_NAME, VALUE_TYPE)
1327//%- (void)addEntriesFromDictionary:(GPBBool##VALUE_NAME##Dictionary *)otherDictionary {
1328//%  if (otherDictionary) {
1329//%    for (int i = 0; i < 2; ++i) {
1330//%      if (otherDictionary->_values[i] != nil) {
1331//%        [_values[i] release];
1332//%        _values[i] = [otherDictionary->_values[i] retain];
1333//%      }
1334//%    }
1335//%    if (_autocreator) {
1336//%      GPBAutocreatedDictionaryModified(_autocreator, self);
1337//%    }
1338//%  }
1339//%}
1340//%
1341//%- (void)setObject:(VALUE_TYPE)object forKey:(BOOL)key {
1342//%  if (!object) {
1343//%    [NSException raise:NSInvalidArgumentException
1344//%                format:@"Attempting to add nil object to a Dictionary"];
1345//%  }
1346//%  int idx = (key ? 1 : 0);
1347//%  [_values[idx] release];
1348//%  _values[idx] = [object retain];
1349//%  if (_autocreator) {
1350//%    GPBAutocreatedDictionaryModified(_autocreator, self);
1351//%  }
1352//%}
1353//%
1354//%- (void)removeObjectForKey:(BOOL)aKey {
1355//%  int idx = (aKey ? 1 : 0);
1356//%  [_values[idx] release];
1357//%  _values[idx] = nil;
1358//%}
1359//%
1360//%- (void)removeAll {
1361//%  for (int i = 0; i < 2; ++i) {
1362//%    [_values[i] release];
1363//%    _values[i] = nil;
1364//%  }
1365//%}
1366//%PDDM-DEFINE STR_FORMAT_OBJECT(VALUE_NAME)
1367//%%@
1368
1369
1370//%PDDM-EXPAND DICTIONARY_IMPL_FOR_POD_KEY(UInt32, uint32_t)
1371// This block of code is generated, do not edit it directly.
1372
1373#pragma mark - UInt32 -> UInt32
1374
1375@implementation GPBUInt32UInt32Dictionary {
1376 @package
1377  NSMutableDictionary *_dictionary;
1378}
1379
1380- (instancetype)init {
1381  return [self initWithUInt32s:NULL forKeys:NULL count:0];
1382}
1383
1384- (instancetype)initWithUInt32s:(const uint32_t [])values
1385                        forKeys:(const uint32_t [])keys
1386                          count:(NSUInteger)count {
1387  self = [super init];
1388  if (self) {
1389    _dictionary = [[NSMutableDictionary alloc] init];
1390    if (count && values && keys) {
1391      for (NSUInteger i = 0; i < count; ++i) {
1392        [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
1393      }
1394    }
1395  }
1396  return self;
1397}
1398
1399- (instancetype)initWithDictionary:(GPBUInt32UInt32Dictionary *)dictionary {
1400  self = [self initWithUInt32s:NULL forKeys:NULL count:0];
1401  if (self) {
1402    if (dictionary) {
1403      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
1404    }
1405  }
1406  return self;
1407}
1408
1409- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
1410  return [self initWithUInt32s:NULL forKeys:NULL count:0];
1411}
1412
1413- (void)dealloc {
1414  NSAssert(!_autocreator,
1415           @"%@: Autocreator must be cleared before release, autocreator: %@",
1416           [self class], _autocreator);
1417  [_dictionary release];
1418  [super dealloc];
1419}
1420
1421- (instancetype)copyWithZone:(NSZone *)zone {
1422  return [[GPBUInt32UInt32Dictionary allocWithZone:zone] initWithDictionary:self];
1423}
1424
1425- (BOOL)isEqual:(id)other {
1426  if (self == other) {
1427    return YES;
1428  }
1429  if (![other isKindOfClass:[GPBUInt32UInt32Dictionary class]]) {
1430    return NO;
1431  }
1432  GPBUInt32UInt32Dictionary *otherDictionary = other;
1433  return [_dictionary isEqual:otherDictionary->_dictionary];
1434}
1435
1436- (NSUInteger)hash {
1437  return _dictionary.count;
1438}
1439
1440- (NSString *)description {
1441  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
1442}
1443
1444- (NSUInteger)count {
1445  return _dictionary.count;
1446}
1447
1448- (void)enumerateKeysAndUInt32sUsingBlock:
1449    (void (NS_NOESCAPE ^)(uint32_t key, uint32_t value, BOOL *stop))block {
1450  BOOL stop = NO;
1451  NSDictionary *internal = _dictionary;
1452  NSEnumerator *keys = [internal keyEnumerator];
1453  NSNumber *aKey;
1454  while ((aKey = [keys nextObject])) {
1455    NSNumber *aValue = internal[aKey];
1456    block([aKey unsignedIntValue], [aValue unsignedIntValue], &stop);
1457    if (stop) {
1458      break;
1459    }
1460  }
1461}
1462
1463- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
1464  NSDictionary *internal = _dictionary;
1465  NSUInteger count = internal.count;
1466  if (count == 0) {
1467    return 0;
1468  }
1469
1470  GPBDataType valueDataType = GPBGetFieldDataType(field);
1471  GPBDataType keyDataType = field.mapKeyDataType;
1472  size_t result = 0;
1473  NSEnumerator *keys = [internal keyEnumerator];
1474  NSNumber *aKey;
1475  while ((aKey = [keys nextObject])) {
1476    NSNumber *aValue = internal[aKey];
1477    size_t msgSize = ComputeDictUInt32FieldSize([aKey unsignedIntValue], kMapKeyFieldNumber, keyDataType);
1478    msgSize += ComputeDictUInt32FieldSize([aValue unsignedIntValue], kMapValueFieldNumber, valueDataType);
1479    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
1480  }
1481  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
1482  result += tagSize * count;
1483  return result;
1484}
1485
1486- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
1487                         asField:(GPBFieldDescriptor *)field {
1488  GPBDataType valueDataType = GPBGetFieldDataType(field);
1489  GPBDataType keyDataType = field.mapKeyDataType;
1490  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
1491  NSDictionary *internal = _dictionary;
1492  NSEnumerator *keys = [internal keyEnumerator];
1493  NSNumber *aKey;
1494  while ((aKey = [keys nextObject])) {
1495    NSNumber *aValue = internal[aKey];
1496    [outputStream writeInt32NoTag:tag];
1497    // Write the size of the message.
1498    uint32_t unwrappedKey = [aKey unsignedIntValue];
1499    uint32_t unwrappedValue = [aValue unsignedIntValue];
1500    size_t msgSize = ComputeDictUInt32FieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
1501    msgSize += ComputeDictUInt32FieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
1502    [outputStream writeInt32NoTag:(int32_t)msgSize];
1503    // Write the fields.
1504    WriteDictUInt32Field(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
1505    WriteDictUInt32Field(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
1506  }
1507}
1508
1509- (void)setGPBGenericValue:(GPBGenericValue *)value
1510     forGPBGenericValueKey:(GPBGenericValue *)key {
1511  [_dictionary setObject:@(value->valueUInt32) forKey:@(key->valueUInt32)];
1512}
1513
1514- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
1515  [self enumerateKeysAndUInt32sUsingBlock:^(uint32_t key, uint32_t value, __unused BOOL *stop) {
1516      block([NSString stringWithFormat:@"%u", key], [NSString stringWithFormat:@"%u", value]);
1517  }];
1518}
1519
1520- (BOOL)getUInt32:(nullable uint32_t *)value forKey:(uint32_t)key {
1521  NSNumber *wrapped = [_dictionary objectForKey:@(key)];
1522  if (wrapped && value) {
1523    *value = [wrapped unsignedIntValue];
1524  }
1525  return (wrapped != NULL);
1526}
1527
1528- (void)addEntriesFromDictionary:(GPBUInt32UInt32Dictionary *)otherDictionary {
1529  if (otherDictionary) {
1530    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
1531    if (_autocreator) {
1532      GPBAutocreatedDictionaryModified(_autocreator, self);
1533    }
1534  }
1535}
1536
1537- (void)setUInt32:(uint32_t)value forKey:(uint32_t)key {
1538  [_dictionary setObject:@(value) forKey:@(key)];
1539  if (_autocreator) {
1540    GPBAutocreatedDictionaryModified(_autocreator, self);
1541  }
1542}
1543
1544- (void)removeUInt32ForKey:(uint32_t)aKey {
1545  [_dictionary removeObjectForKey:@(aKey)];
1546}
1547
1548- (void)removeAll {
1549  [_dictionary removeAllObjects];
1550}
1551
1552@end
1553
1554#pragma mark - UInt32 -> Int32
1555
1556@implementation GPBUInt32Int32Dictionary {
1557 @package
1558  NSMutableDictionary *_dictionary;
1559}
1560
1561- (instancetype)init {
1562  return [self initWithInt32s:NULL forKeys:NULL count:0];
1563}
1564
1565- (instancetype)initWithInt32s:(const int32_t [])values
1566                       forKeys:(const uint32_t [])keys
1567                         count:(NSUInteger)count {
1568  self = [super init];
1569  if (self) {
1570    _dictionary = [[NSMutableDictionary alloc] init];
1571    if (count && values && keys) {
1572      for (NSUInteger i = 0; i < count; ++i) {
1573        [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
1574      }
1575    }
1576  }
1577  return self;
1578}
1579
1580- (instancetype)initWithDictionary:(GPBUInt32Int32Dictionary *)dictionary {
1581  self = [self initWithInt32s:NULL forKeys:NULL count:0];
1582  if (self) {
1583    if (dictionary) {
1584      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
1585    }
1586  }
1587  return self;
1588}
1589
1590- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
1591  return [self initWithInt32s:NULL forKeys:NULL count:0];
1592}
1593
1594- (void)dealloc {
1595  NSAssert(!_autocreator,
1596           @"%@: Autocreator must be cleared before release, autocreator: %@",
1597           [self class], _autocreator);
1598  [_dictionary release];
1599  [super dealloc];
1600}
1601
1602- (instancetype)copyWithZone:(NSZone *)zone {
1603  return [[GPBUInt32Int32Dictionary allocWithZone:zone] initWithDictionary:self];
1604}
1605
1606- (BOOL)isEqual:(id)other {
1607  if (self == other) {
1608    return YES;
1609  }
1610  if (![other isKindOfClass:[GPBUInt32Int32Dictionary class]]) {
1611    return NO;
1612  }
1613  GPBUInt32Int32Dictionary *otherDictionary = other;
1614  return [_dictionary isEqual:otherDictionary->_dictionary];
1615}
1616
1617- (NSUInteger)hash {
1618  return _dictionary.count;
1619}
1620
1621- (NSString *)description {
1622  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
1623}
1624
1625- (NSUInteger)count {
1626  return _dictionary.count;
1627}
1628
1629- (void)enumerateKeysAndInt32sUsingBlock:
1630    (void (NS_NOESCAPE ^)(uint32_t key, int32_t value, BOOL *stop))block {
1631  BOOL stop = NO;
1632  NSDictionary *internal = _dictionary;
1633  NSEnumerator *keys = [internal keyEnumerator];
1634  NSNumber *aKey;
1635  while ((aKey = [keys nextObject])) {
1636    NSNumber *aValue = internal[aKey];
1637    block([aKey unsignedIntValue], [aValue intValue], &stop);
1638    if (stop) {
1639      break;
1640    }
1641  }
1642}
1643
1644- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
1645  NSDictionary *internal = _dictionary;
1646  NSUInteger count = internal.count;
1647  if (count == 0) {
1648    return 0;
1649  }
1650
1651  GPBDataType valueDataType = GPBGetFieldDataType(field);
1652  GPBDataType keyDataType = field.mapKeyDataType;
1653  size_t result = 0;
1654  NSEnumerator *keys = [internal keyEnumerator];
1655  NSNumber *aKey;
1656  while ((aKey = [keys nextObject])) {
1657    NSNumber *aValue = internal[aKey];
1658    size_t msgSize = ComputeDictUInt32FieldSize([aKey unsignedIntValue], kMapKeyFieldNumber, keyDataType);
1659    msgSize += ComputeDictInt32FieldSize([aValue intValue], kMapValueFieldNumber, valueDataType);
1660    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
1661  }
1662  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
1663  result += tagSize * count;
1664  return result;
1665}
1666
1667- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
1668                         asField:(GPBFieldDescriptor *)field {
1669  GPBDataType valueDataType = GPBGetFieldDataType(field);
1670  GPBDataType keyDataType = field.mapKeyDataType;
1671  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
1672  NSDictionary *internal = _dictionary;
1673  NSEnumerator *keys = [internal keyEnumerator];
1674  NSNumber *aKey;
1675  while ((aKey = [keys nextObject])) {
1676    NSNumber *aValue = internal[aKey];
1677    [outputStream writeInt32NoTag:tag];
1678    // Write the size of the message.
1679    uint32_t unwrappedKey = [aKey unsignedIntValue];
1680    int32_t unwrappedValue = [aValue intValue];
1681    size_t msgSize = ComputeDictUInt32FieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
1682    msgSize += ComputeDictInt32FieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
1683    [outputStream writeInt32NoTag:(int32_t)msgSize];
1684    // Write the fields.
1685    WriteDictUInt32Field(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
1686    WriteDictInt32Field(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
1687  }
1688}
1689
1690- (void)setGPBGenericValue:(GPBGenericValue *)value
1691     forGPBGenericValueKey:(GPBGenericValue *)key {
1692  [_dictionary setObject:@(value->valueInt32) forKey:@(key->valueUInt32)];
1693}
1694
1695- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
1696  [self enumerateKeysAndInt32sUsingBlock:^(uint32_t key, int32_t value, __unused BOOL *stop) {
1697      block([NSString stringWithFormat:@"%u", key], [NSString stringWithFormat:@"%d", value]);
1698  }];
1699}
1700
1701- (BOOL)getInt32:(nullable int32_t *)value forKey:(uint32_t)key {
1702  NSNumber *wrapped = [_dictionary objectForKey:@(key)];
1703  if (wrapped && value) {
1704    *value = [wrapped intValue];
1705  }
1706  return (wrapped != NULL);
1707}
1708
1709- (void)addEntriesFromDictionary:(GPBUInt32Int32Dictionary *)otherDictionary {
1710  if (otherDictionary) {
1711    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
1712    if (_autocreator) {
1713      GPBAutocreatedDictionaryModified(_autocreator, self);
1714    }
1715  }
1716}
1717
1718- (void)setInt32:(int32_t)value forKey:(uint32_t)key {
1719  [_dictionary setObject:@(value) forKey:@(key)];
1720  if (_autocreator) {
1721    GPBAutocreatedDictionaryModified(_autocreator, self);
1722  }
1723}
1724
1725- (void)removeInt32ForKey:(uint32_t)aKey {
1726  [_dictionary removeObjectForKey:@(aKey)];
1727}
1728
1729- (void)removeAll {
1730  [_dictionary removeAllObjects];
1731}
1732
1733@end
1734
1735#pragma mark - UInt32 -> UInt64
1736
1737@implementation GPBUInt32UInt64Dictionary {
1738 @package
1739  NSMutableDictionary *_dictionary;
1740}
1741
1742- (instancetype)init {
1743  return [self initWithUInt64s:NULL forKeys:NULL count:0];
1744}
1745
1746- (instancetype)initWithUInt64s:(const uint64_t [])values
1747                        forKeys:(const uint32_t [])keys
1748                          count:(NSUInteger)count {
1749  self = [super init];
1750  if (self) {
1751    _dictionary = [[NSMutableDictionary alloc] init];
1752    if (count && values && keys) {
1753      for (NSUInteger i = 0; i < count; ++i) {
1754        [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
1755      }
1756    }
1757  }
1758  return self;
1759}
1760
1761- (instancetype)initWithDictionary:(GPBUInt32UInt64Dictionary *)dictionary {
1762  self = [self initWithUInt64s:NULL forKeys:NULL count:0];
1763  if (self) {
1764    if (dictionary) {
1765      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
1766    }
1767  }
1768  return self;
1769}
1770
1771- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
1772  return [self initWithUInt64s:NULL forKeys:NULL count:0];
1773}
1774
1775- (void)dealloc {
1776  NSAssert(!_autocreator,
1777           @"%@: Autocreator must be cleared before release, autocreator: %@",
1778           [self class], _autocreator);
1779  [_dictionary release];
1780  [super dealloc];
1781}
1782
1783- (instancetype)copyWithZone:(NSZone *)zone {
1784  return [[GPBUInt32UInt64Dictionary allocWithZone:zone] initWithDictionary:self];
1785}
1786
1787- (BOOL)isEqual:(id)other {
1788  if (self == other) {
1789    return YES;
1790  }
1791  if (![other isKindOfClass:[GPBUInt32UInt64Dictionary class]]) {
1792    return NO;
1793  }
1794  GPBUInt32UInt64Dictionary *otherDictionary = other;
1795  return [_dictionary isEqual:otherDictionary->_dictionary];
1796}
1797
1798- (NSUInteger)hash {
1799  return _dictionary.count;
1800}
1801
1802- (NSString *)description {
1803  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
1804}
1805
1806- (NSUInteger)count {
1807  return _dictionary.count;
1808}
1809
1810- (void)enumerateKeysAndUInt64sUsingBlock:
1811    (void (NS_NOESCAPE ^)(uint32_t key, uint64_t value, BOOL *stop))block {
1812  BOOL stop = NO;
1813  NSDictionary *internal = _dictionary;
1814  NSEnumerator *keys = [internal keyEnumerator];
1815  NSNumber *aKey;
1816  while ((aKey = [keys nextObject])) {
1817    NSNumber *aValue = internal[aKey];
1818    block([aKey unsignedIntValue], [aValue unsignedLongLongValue], &stop);
1819    if (stop) {
1820      break;
1821    }
1822  }
1823}
1824
1825- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
1826  NSDictionary *internal = _dictionary;
1827  NSUInteger count = internal.count;
1828  if (count == 0) {
1829    return 0;
1830  }
1831
1832  GPBDataType valueDataType = GPBGetFieldDataType(field);
1833  GPBDataType keyDataType = field.mapKeyDataType;
1834  size_t result = 0;
1835  NSEnumerator *keys = [internal keyEnumerator];
1836  NSNumber *aKey;
1837  while ((aKey = [keys nextObject])) {
1838    NSNumber *aValue = internal[aKey];
1839    size_t msgSize = ComputeDictUInt32FieldSize([aKey unsignedIntValue], kMapKeyFieldNumber, keyDataType);
1840    msgSize += ComputeDictUInt64FieldSize([aValue unsignedLongLongValue], kMapValueFieldNumber, valueDataType);
1841    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
1842  }
1843  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
1844  result += tagSize * count;
1845  return result;
1846}
1847
1848- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
1849                         asField:(GPBFieldDescriptor *)field {
1850  GPBDataType valueDataType = GPBGetFieldDataType(field);
1851  GPBDataType keyDataType = field.mapKeyDataType;
1852  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
1853  NSDictionary *internal = _dictionary;
1854  NSEnumerator *keys = [internal keyEnumerator];
1855  NSNumber *aKey;
1856  while ((aKey = [keys nextObject])) {
1857    NSNumber *aValue = internal[aKey];
1858    [outputStream writeInt32NoTag:tag];
1859    // Write the size of the message.
1860    uint32_t unwrappedKey = [aKey unsignedIntValue];
1861    uint64_t unwrappedValue = [aValue unsignedLongLongValue];
1862    size_t msgSize = ComputeDictUInt32FieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
1863    msgSize += ComputeDictUInt64FieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
1864    [outputStream writeInt32NoTag:(int32_t)msgSize];
1865    // Write the fields.
1866    WriteDictUInt32Field(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
1867    WriteDictUInt64Field(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
1868  }
1869}
1870
1871- (void)setGPBGenericValue:(GPBGenericValue *)value
1872     forGPBGenericValueKey:(GPBGenericValue *)key {
1873  [_dictionary setObject:@(value->valueUInt64) forKey:@(key->valueUInt32)];
1874}
1875
1876- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
1877  [self enumerateKeysAndUInt64sUsingBlock:^(uint32_t key, uint64_t value, __unused BOOL *stop) {
1878      block([NSString stringWithFormat:@"%u", key], [NSString stringWithFormat:@"%llu", value]);
1879  }];
1880}
1881
1882- (BOOL)getUInt64:(nullable uint64_t *)value forKey:(uint32_t)key {
1883  NSNumber *wrapped = [_dictionary objectForKey:@(key)];
1884  if (wrapped && value) {
1885    *value = [wrapped unsignedLongLongValue];
1886  }
1887  return (wrapped != NULL);
1888}
1889
1890- (void)addEntriesFromDictionary:(GPBUInt32UInt64Dictionary *)otherDictionary {
1891  if (otherDictionary) {
1892    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
1893    if (_autocreator) {
1894      GPBAutocreatedDictionaryModified(_autocreator, self);
1895    }
1896  }
1897}
1898
1899- (void)setUInt64:(uint64_t)value forKey:(uint32_t)key {
1900  [_dictionary setObject:@(value) forKey:@(key)];
1901  if (_autocreator) {
1902    GPBAutocreatedDictionaryModified(_autocreator, self);
1903  }
1904}
1905
1906- (void)removeUInt64ForKey:(uint32_t)aKey {
1907  [_dictionary removeObjectForKey:@(aKey)];
1908}
1909
1910- (void)removeAll {
1911  [_dictionary removeAllObjects];
1912}
1913
1914@end
1915
1916#pragma mark - UInt32 -> Int64
1917
1918@implementation GPBUInt32Int64Dictionary {
1919 @package
1920  NSMutableDictionary *_dictionary;
1921}
1922
1923- (instancetype)init {
1924  return [self initWithInt64s:NULL forKeys:NULL count:0];
1925}
1926
1927- (instancetype)initWithInt64s:(const int64_t [])values
1928                       forKeys:(const uint32_t [])keys
1929                         count:(NSUInteger)count {
1930  self = [super init];
1931  if (self) {
1932    _dictionary = [[NSMutableDictionary alloc] init];
1933    if (count && values && keys) {
1934      for (NSUInteger i = 0; i < count; ++i) {
1935        [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
1936      }
1937    }
1938  }
1939  return self;
1940}
1941
1942- (instancetype)initWithDictionary:(GPBUInt32Int64Dictionary *)dictionary {
1943  self = [self initWithInt64s:NULL forKeys:NULL count:0];
1944  if (self) {
1945    if (dictionary) {
1946      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
1947    }
1948  }
1949  return self;
1950}
1951
1952- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
1953  return [self initWithInt64s:NULL forKeys:NULL count:0];
1954}
1955
1956- (void)dealloc {
1957  NSAssert(!_autocreator,
1958           @"%@: Autocreator must be cleared before release, autocreator: %@",
1959           [self class], _autocreator);
1960  [_dictionary release];
1961  [super dealloc];
1962}
1963
1964- (instancetype)copyWithZone:(NSZone *)zone {
1965  return [[GPBUInt32Int64Dictionary allocWithZone:zone] initWithDictionary:self];
1966}
1967
1968- (BOOL)isEqual:(id)other {
1969  if (self == other) {
1970    return YES;
1971  }
1972  if (![other isKindOfClass:[GPBUInt32Int64Dictionary class]]) {
1973    return NO;
1974  }
1975  GPBUInt32Int64Dictionary *otherDictionary = other;
1976  return [_dictionary isEqual:otherDictionary->_dictionary];
1977}
1978
1979- (NSUInteger)hash {
1980  return _dictionary.count;
1981}
1982
1983- (NSString *)description {
1984  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
1985}
1986
1987- (NSUInteger)count {
1988  return _dictionary.count;
1989}
1990
1991- (void)enumerateKeysAndInt64sUsingBlock:
1992    (void (NS_NOESCAPE ^)(uint32_t key, int64_t value, BOOL *stop))block {
1993  BOOL stop = NO;
1994  NSDictionary *internal = _dictionary;
1995  NSEnumerator *keys = [internal keyEnumerator];
1996  NSNumber *aKey;
1997  while ((aKey = [keys nextObject])) {
1998    NSNumber *aValue = internal[aKey];
1999    block([aKey unsignedIntValue], [aValue longLongValue], &stop);
2000    if (stop) {
2001      break;
2002    }
2003  }
2004}
2005
2006- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
2007  NSDictionary *internal = _dictionary;
2008  NSUInteger count = internal.count;
2009  if (count == 0) {
2010    return 0;
2011  }
2012
2013  GPBDataType valueDataType = GPBGetFieldDataType(field);
2014  GPBDataType keyDataType = field.mapKeyDataType;
2015  size_t result = 0;
2016  NSEnumerator *keys = [internal keyEnumerator];
2017  NSNumber *aKey;
2018  while ((aKey = [keys nextObject])) {
2019    NSNumber *aValue = internal[aKey];
2020    size_t msgSize = ComputeDictUInt32FieldSize([aKey unsignedIntValue], kMapKeyFieldNumber, keyDataType);
2021    msgSize += ComputeDictInt64FieldSize([aValue longLongValue], kMapValueFieldNumber, valueDataType);
2022    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
2023  }
2024  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
2025  result += tagSize * count;
2026  return result;
2027}
2028
2029- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
2030                         asField:(GPBFieldDescriptor *)field {
2031  GPBDataType valueDataType = GPBGetFieldDataType(field);
2032  GPBDataType keyDataType = field.mapKeyDataType;
2033  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
2034  NSDictionary *internal = _dictionary;
2035  NSEnumerator *keys = [internal keyEnumerator];
2036  NSNumber *aKey;
2037  while ((aKey = [keys nextObject])) {
2038    NSNumber *aValue = internal[aKey];
2039    [outputStream writeInt32NoTag:tag];
2040    // Write the size of the message.
2041    uint32_t unwrappedKey = [aKey unsignedIntValue];
2042    int64_t unwrappedValue = [aValue longLongValue];
2043    size_t msgSize = ComputeDictUInt32FieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
2044    msgSize += ComputeDictInt64FieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
2045    [outputStream writeInt32NoTag:(int32_t)msgSize];
2046    // Write the fields.
2047    WriteDictUInt32Field(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
2048    WriteDictInt64Field(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
2049  }
2050}
2051
2052- (void)setGPBGenericValue:(GPBGenericValue *)value
2053     forGPBGenericValueKey:(GPBGenericValue *)key {
2054  [_dictionary setObject:@(value->valueInt64) forKey:@(key->valueUInt32)];
2055}
2056
2057- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
2058  [self enumerateKeysAndInt64sUsingBlock:^(uint32_t key, int64_t value, __unused BOOL *stop) {
2059      block([NSString stringWithFormat:@"%u", key], [NSString stringWithFormat:@"%lld", value]);
2060  }];
2061}
2062
2063- (BOOL)getInt64:(nullable int64_t *)value forKey:(uint32_t)key {
2064  NSNumber *wrapped = [_dictionary objectForKey:@(key)];
2065  if (wrapped && value) {
2066    *value = [wrapped longLongValue];
2067  }
2068  return (wrapped != NULL);
2069}
2070
2071- (void)addEntriesFromDictionary:(GPBUInt32Int64Dictionary *)otherDictionary {
2072  if (otherDictionary) {
2073    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
2074    if (_autocreator) {
2075      GPBAutocreatedDictionaryModified(_autocreator, self);
2076    }
2077  }
2078}
2079
2080- (void)setInt64:(int64_t)value forKey:(uint32_t)key {
2081  [_dictionary setObject:@(value) forKey:@(key)];
2082  if (_autocreator) {
2083    GPBAutocreatedDictionaryModified(_autocreator, self);
2084  }
2085}
2086
2087- (void)removeInt64ForKey:(uint32_t)aKey {
2088  [_dictionary removeObjectForKey:@(aKey)];
2089}
2090
2091- (void)removeAll {
2092  [_dictionary removeAllObjects];
2093}
2094
2095@end
2096
2097#pragma mark - UInt32 -> Bool
2098
2099@implementation GPBUInt32BoolDictionary {
2100 @package
2101  NSMutableDictionary *_dictionary;
2102}
2103
2104- (instancetype)init {
2105  return [self initWithBools:NULL forKeys:NULL count:0];
2106}
2107
2108- (instancetype)initWithBools:(const BOOL [])values
2109                      forKeys:(const uint32_t [])keys
2110                        count:(NSUInteger)count {
2111  self = [super init];
2112  if (self) {
2113    _dictionary = [[NSMutableDictionary alloc] init];
2114    if (count && values && keys) {
2115      for (NSUInteger i = 0; i < count; ++i) {
2116        [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
2117      }
2118    }
2119  }
2120  return self;
2121}
2122
2123- (instancetype)initWithDictionary:(GPBUInt32BoolDictionary *)dictionary {
2124  self = [self initWithBools:NULL forKeys:NULL count:0];
2125  if (self) {
2126    if (dictionary) {
2127      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
2128    }
2129  }
2130  return self;
2131}
2132
2133- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
2134  return [self initWithBools:NULL forKeys:NULL count:0];
2135}
2136
2137- (void)dealloc {
2138  NSAssert(!_autocreator,
2139           @"%@: Autocreator must be cleared before release, autocreator: %@",
2140           [self class], _autocreator);
2141  [_dictionary release];
2142  [super dealloc];
2143}
2144
2145- (instancetype)copyWithZone:(NSZone *)zone {
2146  return [[GPBUInt32BoolDictionary allocWithZone:zone] initWithDictionary:self];
2147}
2148
2149- (BOOL)isEqual:(id)other {
2150  if (self == other) {
2151    return YES;
2152  }
2153  if (![other isKindOfClass:[GPBUInt32BoolDictionary class]]) {
2154    return NO;
2155  }
2156  GPBUInt32BoolDictionary *otherDictionary = other;
2157  return [_dictionary isEqual:otherDictionary->_dictionary];
2158}
2159
2160- (NSUInteger)hash {
2161  return _dictionary.count;
2162}
2163
2164- (NSString *)description {
2165  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
2166}
2167
2168- (NSUInteger)count {
2169  return _dictionary.count;
2170}
2171
2172- (void)enumerateKeysAndBoolsUsingBlock:
2173    (void (NS_NOESCAPE ^)(uint32_t key, BOOL value, BOOL *stop))block {
2174  BOOL stop = NO;
2175  NSDictionary *internal = _dictionary;
2176  NSEnumerator *keys = [internal keyEnumerator];
2177  NSNumber *aKey;
2178  while ((aKey = [keys nextObject])) {
2179    NSNumber *aValue = internal[aKey];
2180    block([aKey unsignedIntValue], [aValue boolValue], &stop);
2181    if (stop) {
2182      break;
2183    }
2184  }
2185}
2186
2187- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
2188  NSDictionary *internal = _dictionary;
2189  NSUInteger count = internal.count;
2190  if (count == 0) {
2191    return 0;
2192  }
2193
2194  GPBDataType valueDataType = GPBGetFieldDataType(field);
2195  GPBDataType keyDataType = field.mapKeyDataType;
2196  size_t result = 0;
2197  NSEnumerator *keys = [internal keyEnumerator];
2198  NSNumber *aKey;
2199  while ((aKey = [keys nextObject])) {
2200    NSNumber *aValue = internal[aKey];
2201    size_t msgSize = ComputeDictUInt32FieldSize([aKey unsignedIntValue], kMapKeyFieldNumber, keyDataType);
2202    msgSize += ComputeDictBoolFieldSize([aValue boolValue], kMapValueFieldNumber, valueDataType);
2203    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
2204  }
2205  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
2206  result += tagSize * count;
2207  return result;
2208}
2209
2210- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
2211                         asField:(GPBFieldDescriptor *)field {
2212  GPBDataType valueDataType = GPBGetFieldDataType(field);
2213  GPBDataType keyDataType = field.mapKeyDataType;
2214  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
2215  NSDictionary *internal = _dictionary;
2216  NSEnumerator *keys = [internal keyEnumerator];
2217  NSNumber *aKey;
2218  while ((aKey = [keys nextObject])) {
2219    NSNumber *aValue = internal[aKey];
2220    [outputStream writeInt32NoTag:tag];
2221    // Write the size of the message.
2222    uint32_t unwrappedKey = [aKey unsignedIntValue];
2223    BOOL unwrappedValue = [aValue boolValue];
2224    size_t msgSize = ComputeDictUInt32FieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
2225    msgSize += ComputeDictBoolFieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
2226    [outputStream writeInt32NoTag:(int32_t)msgSize];
2227    // Write the fields.
2228    WriteDictUInt32Field(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
2229    WriteDictBoolField(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
2230  }
2231}
2232
2233- (void)setGPBGenericValue:(GPBGenericValue *)value
2234     forGPBGenericValueKey:(GPBGenericValue *)key {
2235  [_dictionary setObject:@(value->valueBool) forKey:@(key->valueUInt32)];
2236}
2237
2238- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
2239  [self enumerateKeysAndBoolsUsingBlock:^(uint32_t key, BOOL value, __unused BOOL *stop) {
2240      block([NSString stringWithFormat:@"%u", key], (value ? @"true" : @"false"));
2241  }];
2242}
2243
2244- (BOOL)getBool:(nullable BOOL *)value forKey:(uint32_t)key {
2245  NSNumber *wrapped = [_dictionary objectForKey:@(key)];
2246  if (wrapped && value) {
2247    *value = [wrapped boolValue];
2248  }
2249  return (wrapped != NULL);
2250}
2251
2252- (void)addEntriesFromDictionary:(GPBUInt32BoolDictionary *)otherDictionary {
2253  if (otherDictionary) {
2254    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
2255    if (_autocreator) {
2256      GPBAutocreatedDictionaryModified(_autocreator, self);
2257    }
2258  }
2259}
2260
2261- (void)setBool:(BOOL)value forKey:(uint32_t)key {
2262  [_dictionary setObject:@(value) forKey:@(key)];
2263  if (_autocreator) {
2264    GPBAutocreatedDictionaryModified(_autocreator, self);
2265  }
2266}
2267
2268- (void)removeBoolForKey:(uint32_t)aKey {
2269  [_dictionary removeObjectForKey:@(aKey)];
2270}
2271
2272- (void)removeAll {
2273  [_dictionary removeAllObjects];
2274}
2275
2276@end
2277
2278#pragma mark - UInt32 -> Float
2279
2280@implementation GPBUInt32FloatDictionary {
2281 @package
2282  NSMutableDictionary *_dictionary;
2283}
2284
2285- (instancetype)init {
2286  return [self initWithFloats:NULL forKeys:NULL count:0];
2287}
2288
2289- (instancetype)initWithFloats:(const float [])values
2290                       forKeys:(const uint32_t [])keys
2291                         count:(NSUInteger)count {
2292  self = [super init];
2293  if (self) {
2294    _dictionary = [[NSMutableDictionary alloc] init];
2295    if (count && values && keys) {
2296      for (NSUInteger i = 0; i < count; ++i) {
2297        [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
2298      }
2299    }
2300  }
2301  return self;
2302}
2303
2304- (instancetype)initWithDictionary:(GPBUInt32FloatDictionary *)dictionary {
2305  self = [self initWithFloats:NULL forKeys:NULL count:0];
2306  if (self) {
2307    if (dictionary) {
2308      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
2309    }
2310  }
2311  return self;
2312}
2313
2314- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
2315  return [self initWithFloats:NULL forKeys:NULL count:0];
2316}
2317
2318- (void)dealloc {
2319  NSAssert(!_autocreator,
2320           @"%@: Autocreator must be cleared before release, autocreator: %@",
2321           [self class], _autocreator);
2322  [_dictionary release];
2323  [super dealloc];
2324}
2325
2326- (instancetype)copyWithZone:(NSZone *)zone {
2327  return [[GPBUInt32FloatDictionary allocWithZone:zone] initWithDictionary:self];
2328}
2329
2330- (BOOL)isEqual:(id)other {
2331  if (self == other) {
2332    return YES;
2333  }
2334  if (![other isKindOfClass:[GPBUInt32FloatDictionary class]]) {
2335    return NO;
2336  }
2337  GPBUInt32FloatDictionary *otherDictionary = other;
2338  return [_dictionary isEqual:otherDictionary->_dictionary];
2339}
2340
2341- (NSUInteger)hash {
2342  return _dictionary.count;
2343}
2344
2345- (NSString *)description {
2346  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
2347}
2348
2349- (NSUInteger)count {
2350  return _dictionary.count;
2351}
2352
2353- (void)enumerateKeysAndFloatsUsingBlock:
2354    (void (NS_NOESCAPE ^)(uint32_t key, float value, BOOL *stop))block {
2355  BOOL stop = NO;
2356  NSDictionary *internal = _dictionary;
2357  NSEnumerator *keys = [internal keyEnumerator];
2358  NSNumber *aKey;
2359  while ((aKey = [keys nextObject])) {
2360    NSNumber *aValue = internal[aKey];
2361    block([aKey unsignedIntValue], [aValue floatValue], &stop);
2362    if (stop) {
2363      break;
2364    }
2365  }
2366}
2367
2368- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
2369  NSDictionary *internal = _dictionary;
2370  NSUInteger count = internal.count;
2371  if (count == 0) {
2372    return 0;
2373  }
2374
2375  GPBDataType valueDataType = GPBGetFieldDataType(field);
2376  GPBDataType keyDataType = field.mapKeyDataType;
2377  size_t result = 0;
2378  NSEnumerator *keys = [internal keyEnumerator];
2379  NSNumber *aKey;
2380  while ((aKey = [keys nextObject])) {
2381    NSNumber *aValue = internal[aKey];
2382    size_t msgSize = ComputeDictUInt32FieldSize([aKey unsignedIntValue], kMapKeyFieldNumber, keyDataType);
2383    msgSize += ComputeDictFloatFieldSize([aValue floatValue], kMapValueFieldNumber, valueDataType);
2384    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
2385  }
2386  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
2387  result += tagSize * count;
2388  return result;
2389}
2390
2391- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
2392                         asField:(GPBFieldDescriptor *)field {
2393  GPBDataType valueDataType = GPBGetFieldDataType(field);
2394  GPBDataType keyDataType = field.mapKeyDataType;
2395  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
2396  NSDictionary *internal = _dictionary;
2397  NSEnumerator *keys = [internal keyEnumerator];
2398  NSNumber *aKey;
2399  while ((aKey = [keys nextObject])) {
2400    NSNumber *aValue = internal[aKey];
2401    [outputStream writeInt32NoTag:tag];
2402    // Write the size of the message.
2403    uint32_t unwrappedKey = [aKey unsignedIntValue];
2404    float unwrappedValue = [aValue floatValue];
2405    size_t msgSize = ComputeDictUInt32FieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
2406    msgSize += ComputeDictFloatFieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
2407    [outputStream writeInt32NoTag:(int32_t)msgSize];
2408    // Write the fields.
2409    WriteDictUInt32Field(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
2410    WriteDictFloatField(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
2411  }
2412}
2413
2414- (void)setGPBGenericValue:(GPBGenericValue *)value
2415     forGPBGenericValueKey:(GPBGenericValue *)key {
2416  [_dictionary setObject:@(value->valueFloat) forKey:@(key->valueUInt32)];
2417}
2418
2419- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
2420  [self enumerateKeysAndFloatsUsingBlock:^(uint32_t key, float value, __unused BOOL *stop) {
2421      block([NSString stringWithFormat:@"%u", key], [NSString stringWithFormat:@"%.*g", FLT_DIG, value]);
2422  }];
2423}
2424
2425- (BOOL)getFloat:(nullable float *)value forKey:(uint32_t)key {
2426  NSNumber *wrapped = [_dictionary objectForKey:@(key)];
2427  if (wrapped && value) {
2428    *value = [wrapped floatValue];
2429  }
2430  return (wrapped != NULL);
2431}
2432
2433- (void)addEntriesFromDictionary:(GPBUInt32FloatDictionary *)otherDictionary {
2434  if (otherDictionary) {
2435    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
2436    if (_autocreator) {
2437      GPBAutocreatedDictionaryModified(_autocreator, self);
2438    }
2439  }
2440}
2441
2442- (void)setFloat:(float)value forKey:(uint32_t)key {
2443  [_dictionary setObject:@(value) forKey:@(key)];
2444  if (_autocreator) {
2445    GPBAutocreatedDictionaryModified(_autocreator, self);
2446  }
2447}
2448
2449- (void)removeFloatForKey:(uint32_t)aKey {
2450  [_dictionary removeObjectForKey:@(aKey)];
2451}
2452
2453- (void)removeAll {
2454  [_dictionary removeAllObjects];
2455}
2456
2457@end
2458
2459#pragma mark - UInt32 -> Double
2460
2461@implementation GPBUInt32DoubleDictionary {
2462 @package
2463  NSMutableDictionary *_dictionary;
2464}
2465
2466- (instancetype)init {
2467  return [self initWithDoubles:NULL forKeys:NULL count:0];
2468}
2469
2470- (instancetype)initWithDoubles:(const double [])values
2471                        forKeys:(const uint32_t [])keys
2472                          count:(NSUInteger)count {
2473  self = [super init];
2474  if (self) {
2475    _dictionary = [[NSMutableDictionary alloc] init];
2476    if (count && values && keys) {
2477      for (NSUInteger i = 0; i < count; ++i) {
2478        [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
2479      }
2480    }
2481  }
2482  return self;
2483}
2484
2485- (instancetype)initWithDictionary:(GPBUInt32DoubleDictionary *)dictionary {
2486  self = [self initWithDoubles:NULL forKeys:NULL count:0];
2487  if (self) {
2488    if (dictionary) {
2489      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
2490    }
2491  }
2492  return self;
2493}
2494
2495- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
2496  return [self initWithDoubles:NULL forKeys:NULL count:0];
2497}
2498
2499- (void)dealloc {
2500  NSAssert(!_autocreator,
2501           @"%@: Autocreator must be cleared before release, autocreator: %@",
2502           [self class], _autocreator);
2503  [_dictionary release];
2504  [super dealloc];
2505}
2506
2507- (instancetype)copyWithZone:(NSZone *)zone {
2508  return [[GPBUInt32DoubleDictionary allocWithZone:zone] initWithDictionary:self];
2509}
2510
2511- (BOOL)isEqual:(id)other {
2512  if (self == other) {
2513    return YES;
2514  }
2515  if (![other isKindOfClass:[GPBUInt32DoubleDictionary class]]) {
2516    return NO;
2517  }
2518  GPBUInt32DoubleDictionary *otherDictionary = other;
2519  return [_dictionary isEqual:otherDictionary->_dictionary];
2520}
2521
2522- (NSUInteger)hash {
2523  return _dictionary.count;
2524}
2525
2526- (NSString *)description {
2527  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
2528}
2529
2530- (NSUInteger)count {
2531  return _dictionary.count;
2532}
2533
2534- (void)enumerateKeysAndDoublesUsingBlock:
2535    (void (NS_NOESCAPE ^)(uint32_t key, double value, BOOL *stop))block {
2536  BOOL stop = NO;
2537  NSDictionary *internal = _dictionary;
2538  NSEnumerator *keys = [internal keyEnumerator];
2539  NSNumber *aKey;
2540  while ((aKey = [keys nextObject])) {
2541    NSNumber *aValue = internal[aKey];
2542    block([aKey unsignedIntValue], [aValue doubleValue], &stop);
2543    if (stop) {
2544      break;
2545    }
2546  }
2547}
2548
2549- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
2550  NSDictionary *internal = _dictionary;
2551  NSUInteger count = internal.count;
2552  if (count == 0) {
2553    return 0;
2554  }
2555
2556  GPBDataType valueDataType = GPBGetFieldDataType(field);
2557  GPBDataType keyDataType = field.mapKeyDataType;
2558  size_t result = 0;
2559  NSEnumerator *keys = [internal keyEnumerator];
2560  NSNumber *aKey;
2561  while ((aKey = [keys nextObject])) {
2562    NSNumber *aValue = internal[aKey];
2563    size_t msgSize = ComputeDictUInt32FieldSize([aKey unsignedIntValue], kMapKeyFieldNumber, keyDataType);
2564    msgSize += ComputeDictDoubleFieldSize([aValue doubleValue], kMapValueFieldNumber, valueDataType);
2565    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
2566  }
2567  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
2568  result += tagSize * count;
2569  return result;
2570}
2571
2572- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
2573                         asField:(GPBFieldDescriptor *)field {
2574  GPBDataType valueDataType = GPBGetFieldDataType(field);
2575  GPBDataType keyDataType = field.mapKeyDataType;
2576  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
2577  NSDictionary *internal = _dictionary;
2578  NSEnumerator *keys = [internal keyEnumerator];
2579  NSNumber *aKey;
2580  while ((aKey = [keys nextObject])) {
2581    NSNumber *aValue = internal[aKey];
2582    [outputStream writeInt32NoTag:tag];
2583    // Write the size of the message.
2584    uint32_t unwrappedKey = [aKey unsignedIntValue];
2585    double unwrappedValue = [aValue doubleValue];
2586    size_t msgSize = ComputeDictUInt32FieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
2587    msgSize += ComputeDictDoubleFieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
2588    [outputStream writeInt32NoTag:(int32_t)msgSize];
2589    // Write the fields.
2590    WriteDictUInt32Field(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
2591    WriteDictDoubleField(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
2592  }
2593}
2594
2595- (void)setGPBGenericValue:(GPBGenericValue *)value
2596     forGPBGenericValueKey:(GPBGenericValue *)key {
2597  [_dictionary setObject:@(value->valueDouble) forKey:@(key->valueUInt32)];
2598}
2599
2600- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
2601  [self enumerateKeysAndDoublesUsingBlock:^(uint32_t key, double value, __unused BOOL *stop) {
2602      block([NSString stringWithFormat:@"%u", key], [NSString stringWithFormat:@"%.*lg", DBL_DIG, value]);
2603  }];
2604}
2605
2606- (BOOL)getDouble:(nullable double *)value forKey:(uint32_t)key {
2607  NSNumber *wrapped = [_dictionary objectForKey:@(key)];
2608  if (wrapped && value) {
2609    *value = [wrapped doubleValue];
2610  }
2611  return (wrapped != NULL);
2612}
2613
2614- (void)addEntriesFromDictionary:(GPBUInt32DoubleDictionary *)otherDictionary {
2615  if (otherDictionary) {
2616    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
2617    if (_autocreator) {
2618      GPBAutocreatedDictionaryModified(_autocreator, self);
2619    }
2620  }
2621}
2622
2623- (void)setDouble:(double)value forKey:(uint32_t)key {
2624  [_dictionary setObject:@(value) forKey:@(key)];
2625  if (_autocreator) {
2626    GPBAutocreatedDictionaryModified(_autocreator, self);
2627  }
2628}
2629
2630- (void)removeDoubleForKey:(uint32_t)aKey {
2631  [_dictionary removeObjectForKey:@(aKey)];
2632}
2633
2634- (void)removeAll {
2635  [_dictionary removeAllObjects];
2636}
2637
2638@end
2639
2640#pragma mark - UInt32 -> Enum
2641
2642@implementation GPBUInt32EnumDictionary {
2643 @package
2644  NSMutableDictionary *_dictionary;
2645  GPBEnumValidationFunc _validationFunc;
2646}
2647
2648@synthesize validationFunc = _validationFunc;
2649
2650- (instancetype)init {
2651  return [self initWithValidationFunction:NULL rawValues:NULL forKeys:NULL count:0];
2652}
2653
2654- (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func {
2655  return [self initWithValidationFunction:func rawValues:NULL forKeys:NULL count:0];
2656}
2657
2658- (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func
2659                                 rawValues:(const int32_t [])rawValues
2660                                   forKeys:(const uint32_t [])keys
2661                                     count:(NSUInteger)count {
2662  self = [super init];
2663  if (self) {
2664    _dictionary = [[NSMutableDictionary alloc] init];
2665    _validationFunc = (func != NULL ? func : DictDefault_IsValidValue);
2666    if (count && rawValues && keys) {
2667      for (NSUInteger i = 0; i < count; ++i) {
2668        [_dictionary setObject:@(rawValues[i]) forKey:@(keys[i])];
2669      }
2670    }
2671  }
2672  return self;
2673}
2674
2675- (instancetype)initWithDictionary:(GPBUInt32EnumDictionary *)dictionary {
2676  self = [self initWithValidationFunction:dictionary.validationFunc
2677                                rawValues:NULL
2678                                  forKeys:NULL
2679                                    count:0];
2680  if (self) {
2681    if (dictionary) {
2682      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
2683    }
2684  }
2685  return self;
2686}
2687
2688- (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func
2689                                  capacity:(__unused NSUInteger)numItems {
2690  return [self initWithValidationFunction:func rawValues:NULL forKeys:NULL count:0];
2691}
2692
2693- (void)dealloc {
2694  NSAssert(!_autocreator,
2695           @"%@: Autocreator must be cleared before release, autocreator: %@",
2696           [self class], _autocreator);
2697  [_dictionary release];
2698  [super dealloc];
2699}
2700
2701- (instancetype)copyWithZone:(NSZone *)zone {
2702  return [[GPBUInt32EnumDictionary allocWithZone:zone] initWithDictionary:self];
2703}
2704
2705- (BOOL)isEqual:(id)other {
2706  if (self == other) {
2707    return YES;
2708  }
2709  if (![other isKindOfClass:[GPBUInt32EnumDictionary class]]) {
2710    return NO;
2711  }
2712  GPBUInt32EnumDictionary *otherDictionary = other;
2713  return [_dictionary isEqual:otherDictionary->_dictionary];
2714}
2715
2716- (NSUInteger)hash {
2717  return _dictionary.count;
2718}
2719
2720- (NSString *)description {
2721  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
2722}
2723
2724- (NSUInteger)count {
2725  return _dictionary.count;
2726}
2727
2728- (void)enumerateKeysAndRawValuesUsingBlock:
2729    (void (NS_NOESCAPE ^)(uint32_t key, int32_t value, BOOL *stop))block {
2730  BOOL stop = NO;
2731  NSDictionary *internal = _dictionary;
2732  NSEnumerator *keys = [internal keyEnumerator];
2733  NSNumber *aKey;
2734  while ((aKey = [keys nextObject])) {
2735    NSNumber *aValue = internal[aKey];
2736    block([aKey unsignedIntValue], [aValue intValue], &stop);
2737    if (stop) {
2738      break;
2739    }
2740  }
2741}
2742
2743- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
2744  NSDictionary *internal = _dictionary;
2745  NSUInteger count = internal.count;
2746  if (count == 0) {
2747    return 0;
2748  }
2749
2750  GPBDataType valueDataType = GPBGetFieldDataType(field);
2751  GPBDataType keyDataType = field.mapKeyDataType;
2752  size_t result = 0;
2753  NSEnumerator *keys = [internal keyEnumerator];
2754  NSNumber *aKey;
2755  while ((aKey = [keys nextObject])) {
2756    NSNumber *aValue = internal[aKey];
2757    size_t msgSize = ComputeDictUInt32FieldSize([aKey unsignedIntValue], kMapKeyFieldNumber, keyDataType);
2758    msgSize += ComputeDictEnumFieldSize([aValue intValue], kMapValueFieldNumber, valueDataType);
2759    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
2760  }
2761  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
2762  result += tagSize * count;
2763  return result;
2764}
2765
2766- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
2767                         asField:(GPBFieldDescriptor *)field {
2768  GPBDataType valueDataType = GPBGetFieldDataType(field);
2769  GPBDataType keyDataType = field.mapKeyDataType;
2770  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
2771  NSDictionary *internal = _dictionary;
2772  NSEnumerator *keys = [internal keyEnumerator];
2773  NSNumber *aKey;
2774  while ((aKey = [keys nextObject])) {
2775    NSNumber *aValue = internal[aKey];
2776    [outputStream writeInt32NoTag:tag];
2777    // Write the size of the message.
2778    uint32_t unwrappedKey = [aKey unsignedIntValue];
2779    int32_t unwrappedValue = [aValue intValue];
2780    size_t msgSize = ComputeDictUInt32FieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
2781    msgSize += ComputeDictEnumFieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
2782    [outputStream writeInt32NoTag:(int32_t)msgSize];
2783    // Write the fields.
2784    WriteDictUInt32Field(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
2785    WriteDictEnumField(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
2786  }
2787}
2788
2789- (NSData *)serializedDataForUnknownValue:(int32_t)value
2790                                   forKey:(GPBGenericValue *)key
2791                              keyDataType:(GPBDataType)keyDataType {
2792  size_t msgSize = ComputeDictUInt32FieldSize(key->valueUInt32, kMapKeyFieldNumber, keyDataType);
2793  msgSize += ComputeDictEnumFieldSize(value, kMapValueFieldNumber, GPBDataTypeEnum);
2794  NSMutableData *data = [NSMutableData dataWithLength:msgSize];
2795  GPBCodedOutputStream *outputStream = [[GPBCodedOutputStream alloc] initWithData:data];
2796  WriteDictUInt32Field(outputStream, key->valueUInt32, kMapKeyFieldNumber, keyDataType);
2797  WriteDictEnumField(outputStream, value, kMapValueFieldNumber, GPBDataTypeEnum);
2798  [outputStream flush];
2799  [outputStream release];
2800  return data;
2801}
2802- (void)setGPBGenericValue:(GPBGenericValue *)value
2803     forGPBGenericValueKey:(GPBGenericValue *)key {
2804  [_dictionary setObject:@(value->valueEnum) forKey:@(key->valueUInt32)];
2805}
2806
2807- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
2808  [self enumerateKeysAndRawValuesUsingBlock:^(uint32_t key, int32_t value, __unused BOOL *stop) {
2809      block([NSString stringWithFormat:@"%u", key], @(value));
2810  }];
2811}
2812
2813- (BOOL)getEnum:(int32_t *)value forKey:(uint32_t)key {
2814  NSNumber *wrapped = [_dictionary objectForKey:@(key)];
2815  if (wrapped && value) {
2816    int32_t result = [wrapped intValue];
2817    if (!_validationFunc(result)) {
2818      result = kGPBUnrecognizedEnumeratorValue;
2819    }
2820    *value = result;
2821  }
2822  return (wrapped != NULL);
2823}
2824
2825- (BOOL)getRawValue:(int32_t *)rawValue forKey:(uint32_t)key {
2826  NSNumber *wrapped = [_dictionary objectForKey:@(key)];
2827  if (wrapped && rawValue) {
2828    *rawValue = [wrapped intValue];
2829  }
2830  return (wrapped != NULL);
2831}
2832
2833- (void)enumerateKeysAndEnumsUsingBlock:
2834    (void (NS_NOESCAPE ^)(uint32_t key, int32_t value, BOOL *stop))block {
2835  GPBEnumValidationFunc func = _validationFunc;
2836  BOOL stop = NO;
2837  NSEnumerator *keys = [_dictionary keyEnumerator];
2838  NSNumber *aKey;
2839  while ((aKey = [keys nextObject])) {
2840    NSNumber *aValue = _dictionary[aKey];
2841      int32_t unwrapped = [aValue intValue];
2842      if (!func(unwrapped)) {
2843        unwrapped = kGPBUnrecognizedEnumeratorValue;
2844      }
2845    block([aKey unsignedIntValue], unwrapped, &stop);
2846    if (stop) {
2847      break;
2848    }
2849  }
2850}
2851
2852- (void)addRawEntriesFromDictionary:(GPBUInt32EnumDictionary *)otherDictionary {
2853  if (otherDictionary) {
2854    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
2855    if (_autocreator) {
2856      GPBAutocreatedDictionaryModified(_autocreator, self);
2857    }
2858  }
2859}
2860
2861- (void)setRawValue:(int32_t)value forKey:(uint32_t)key {
2862  [_dictionary setObject:@(value) forKey:@(key)];
2863  if (_autocreator) {
2864    GPBAutocreatedDictionaryModified(_autocreator, self);
2865  }
2866}
2867
2868- (void)removeEnumForKey:(uint32_t)aKey {
2869  [_dictionary removeObjectForKey:@(aKey)];
2870}
2871
2872- (void)removeAll {
2873  [_dictionary removeAllObjects];
2874}
2875
2876- (void)setEnum:(int32_t)value forKey:(uint32_t)key {
2877  if (!_validationFunc(value)) {
2878    [NSException raise:NSInvalidArgumentException
2879                format:@"GPBUInt32EnumDictionary: Attempt to set an unknown enum value (%d)",
2880                       value];
2881  }
2882
2883  [_dictionary setObject:@(value) forKey:@(key)];
2884  if (_autocreator) {
2885    GPBAutocreatedDictionaryModified(_autocreator, self);
2886  }
2887}
2888
2889@end
2890
2891#pragma mark - UInt32 -> Object
2892
2893@implementation GPBUInt32ObjectDictionary {
2894 @package
2895  NSMutableDictionary *_dictionary;
2896}
2897
2898- (instancetype)init {
2899  return [self initWithObjects:NULL forKeys:NULL count:0];
2900}
2901
2902- (instancetype)initWithObjects:(const id [])objects
2903                        forKeys:(const uint32_t [])keys
2904                          count:(NSUInteger)count {
2905  self = [super init];
2906  if (self) {
2907    _dictionary = [[NSMutableDictionary alloc] init];
2908    if (count && objects && keys) {
2909      for (NSUInteger i = 0; i < count; ++i) {
2910        if (!objects[i]) {
2911          [NSException raise:NSInvalidArgumentException
2912                      format:@"Attempting to add nil object to a Dictionary"];
2913        }
2914        [_dictionary setObject:objects[i] forKey:@(keys[i])];
2915      }
2916    }
2917  }
2918  return self;
2919}
2920
2921- (instancetype)initWithDictionary:(GPBUInt32ObjectDictionary *)dictionary {
2922  self = [self initWithObjects:NULL forKeys:NULL count:0];
2923  if (self) {
2924    if (dictionary) {
2925      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
2926    }
2927  }
2928  return self;
2929}
2930
2931- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
2932  return [self initWithObjects:NULL forKeys:NULL count:0];
2933}
2934
2935- (void)dealloc {
2936  NSAssert(!_autocreator,
2937           @"%@: Autocreator must be cleared before release, autocreator: %@",
2938           [self class], _autocreator);
2939  [_dictionary release];
2940  [super dealloc];
2941}
2942
2943- (instancetype)copyWithZone:(NSZone *)zone {
2944  return [[GPBUInt32ObjectDictionary allocWithZone:zone] initWithDictionary:self];
2945}
2946
2947- (BOOL)isEqual:(id)other {
2948  if (self == other) {
2949    return YES;
2950  }
2951  if (![other isKindOfClass:[GPBUInt32ObjectDictionary class]]) {
2952    return NO;
2953  }
2954  GPBUInt32ObjectDictionary *otherDictionary = other;
2955  return [_dictionary isEqual:otherDictionary->_dictionary];
2956}
2957
2958- (NSUInteger)hash {
2959  return _dictionary.count;
2960}
2961
2962- (NSString *)description {
2963  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
2964}
2965
2966- (NSUInteger)count {
2967  return _dictionary.count;
2968}
2969
2970- (void)enumerateKeysAndObjectsUsingBlock:
2971    (void (NS_NOESCAPE ^)(uint32_t key, id object, BOOL *stop))block {
2972  BOOL stop = NO;
2973  NSDictionary *internal = _dictionary;
2974  NSEnumerator *keys = [internal keyEnumerator];
2975  NSNumber *aKey;
2976  while ((aKey = [keys nextObject])) {
2977    id aObject = internal[aKey];
2978    block([aKey unsignedIntValue], aObject, &stop);
2979    if (stop) {
2980      break;
2981    }
2982  }
2983}
2984
2985- (BOOL)isInitialized {
2986  for (GPBMessage *msg in [_dictionary objectEnumerator]) {
2987    if (!msg.initialized) {
2988      return NO;
2989    }
2990  }
2991  return YES;
2992}
2993
2994- (instancetype)deepCopyWithZone:(NSZone *)zone {
2995  GPBUInt32ObjectDictionary *newDict =
2996      [[GPBUInt32ObjectDictionary alloc] init];
2997  NSEnumerator *keys = [_dictionary keyEnumerator];
2998  id aKey;
2999  NSMutableDictionary *internalDict = newDict->_dictionary;
3000  while ((aKey = [keys nextObject])) {
3001    GPBMessage *msg = _dictionary[aKey];
3002    GPBMessage *copiedMsg = [msg copyWithZone:zone];
3003    [internalDict setObject:copiedMsg forKey:aKey];
3004    [copiedMsg release];
3005  }
3006  return newDict;
3007}
3008
3009- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
3010  NSDictionary *internal = _dictionary;
3011  NSUInteger count = internal.count;
3012  if (count == 0) {
3013    return 0;
3014  }
3015
3016  GPBDataType valueDataType = GPBGetFieldDataType(field);
3017  GPBDataType keyDataType = field.mapKeyDataType;
3018  size_t result = 0;
3019  NSEnumerator *keys = [internal keyEnumerator];
3020  NSNumber *aKey;
3021  while ((aKey = [keys nextObject])) {
3022    id aObject = internal[aKey];
3023    size_t msgSize = ComputeDictUInt32FieldSize([aKey unsignedIntValue], kMapKeyFieldNumber, keyDataType);
3024    msgSize += ComputeDictObjectFieldSize(aObject, kMapValueFieldNumber, valueDataType);
3025    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
3026  }
3027  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
3028  result += tagSize * count;
3029  return result;
3030}
3031
3032- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
3033                         asField:(GPBFieldDescriptor *)field {
3034  GPBDataType valueDataType = GPBGetFieldDataType(field);
3035  GPBDataType keyDataType = field.mapKeyDataType;
3036  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
3037  NSDictionary *internal = _dictionary;
3038  NSEnumerator *keys = [internal keyEnumerator];
3039  NSNumber *aKey;
3040  while ((aKey = [keys nextObject])) {
3041    id aObject = internal[aKey];
3042    [outputStream writeInt32NoTag:tag];
3043    // Write the size of the message.
3044    uint32_t unwrappedKey = [aKey unsignedIntValue];
3045    id unwrappedValue = aObject;
3046    size_t msgSize = ComputeDictUInt32FieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
3047    msgSize += ComputeDictObjectFieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
3048    [outputStream writeInt32NoTag:(int32_t)msgSize];
3049    // Write the fields.
3050    WriteDictUInt32Field(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
3051    WriteDictObjectField(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
3052  }
3053}
3054
3055- (void)setGPBGenericValue:(GPBGenericValue *)value
3056     forGPBGenericValueKey:(GPBGenericValue *)key {
3057  [_dictionary setObject:value->valueString forKey:@(key->valueUInt32)];
3058}
3059
3060- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
3061  [self enumerateKeysAndObjectsUsingBlock:^(uint32_t key, id object, __unused BOOL *stop) {
3062      block([NSString stringWithFormat:@"%u", key], object);
3063  }];
3064}
3065
3066- (id)objectForKey:(uint32_t)key {
3067  id result = [_dictionary objectForKey:@(key)];
3068  return result;
3069}
3070
3071- (void)addEntriesFromDictionary:(GPBUInt32ObjectDictionary *)otherDictionary {
3072  if (otherDictionary) {
3073    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
3074    if (_autocreator) {
3075      GPBAutocreatedDictionaryModified(_autocreator, self);
3076    }
3077  }
3078}
3079
3080- (void)setObject:(id)object forKey:(uint32_t)key {
3081  if (!object) {
3082    [NSException raise:NSInvalidArgumentException
3083                format:@"Attempting to add nil object to a Dictionary"];
3084  }
3085  [_dictionary setObject:object forKey:@(key)];
3086  if (_autocreator) {
3087    GPBAutocreatedDictionaryModified(_autocreator, self);
3088  }
3089}
3090
3091- (void)removeObjectForKey:(uint32_t)aKey {
3092  [_dictionary removeObjectForKey:@(aKey)];
3093}
3094
3095- (void)removeAll {
3096  [_dictionary removeAllObjects];
3097}
3098
3099@end
3100
3101//%PDDM-EXPAND DICTIONARY_IMPL_FOR_POD_KEY(Int32, int32_t)
3102// This block of code is generated, do not edit it directly.
3103
3104#pragma mark - Int32 -> UInt32
3105
3106@implementation GPBInt32UInt32Dictionary {
3107 @package
3108  NSMutableDictionary *_dictionary;
3109}
3110
3111- (instancetype)init {
3112  return [self initWithUInt32s:NULL forKeys:NULL count:0];
3113}
3114
3115- (instancetype)initWithUInt32s:(const uint32_t [])values
3116                        forKeys:(const int32_t [])keys
3117                          count:(NSUInteger)count {
3118  self = [super init];
3119  if (self) {
3120    _dictionary = [[NSMutableDictionary alloc] init];
3121    if (count && values && keys) {
3122      for (NSUInteger i = 0; i < count; ++i) {
3123        [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
3124      }
3125    }
3126  }
3127  return self;
3128}
3129
3130- (instancetype)initWithDictionary:(GPBInt32UInt32Dictionary *)dictionary {
3131  self = [self initWithUInt32s:NULL forKeys:NULL count:0];
3132  if (self) {
3133    if (dictionary) {
3134      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
3135    }
3136  }
3137  return self;
3138}
3139
3140- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
3141  return [self initWithUInt32s:NULL forKeys:NULL count:0];
3142}
3143
3144- (void)dealloc {
3145  NSAssert(!_autocreator,
3146           @"%@: Autocreator must be cleared before release, autocreator: %@",
3147           [self class], _autocreator);
3148  [_dictionary release];
3149  [super dealloc];
3150}
3151
3152- (instancetype)copyWithZone:(NSZone *)zone {
3153  return [[GPBInt32UInt32Dictionary allocWithZone:zone] initWithDictionary:self];
3154}
3155
3156- (BOOL)isEqual:(id)other {
3157  if (self == other) {
3158    return YES;
3159  }
3160  if (![other isKindOfClass:[GPBInt32UInt32Dictionary class]]) {
3161    return NO;
3162  }
3163  GPBInt32UInt32Dictionary *otherDictionary = other;
3164  return [_dictionary isEqual:otherDictionary->_dictionary];
3165}
3166
3167- (NSUInteger)hash {
3168  return _dictionary.count;
3169}
3170
3171- (NSString *)description {
3172  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
3173}
3174
3175- (NSUInteger)count {
3176  return _dictionary.count;
3177}
3178
3179- (void)enumerateKeysAndUInt32sUsingBlock:
3180    (void (NS_NOESCAPE ^)(int32_t key, uint32_t value, BOOL *stop))block {
3181  BOOL stop = NO;
3182  NSDictionary *internal = _dictionary;
3183  NSEnumerator *keys = [internal keyEnumerator];
3184  NSNumber *aKey;
3185  while ((aKey = [keys nextObject])) {
3186    NSNumber *aValue = internal[aKey];
3187    block([aKey intValue], [aValue unsignedIntValue], &stop);
3188    if (stop) {
3189      break;
3190    }
3191  }
3192}
3193
3194- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
3195  NSDictionary *internal = _dictionary;
3196  NSUInteger count = internal.count;
3197  if (count == 0) {
3198    return 0;
3199  }
3200
3201  GPBDataType valueDataType = GPBGetFieldDataType(field);
3202  GPBDataType keyDataType = field.mapKeyDataType;
3203  size_t result = 0;
3204  NSEnumerator *keys = [internal keyEnumerator];
3205  NSNumber *aKey;
3206  while ((aKey = [keys nextObject])) {
3207    NSNumber *aValue = internal[aKey];
3208    size_t msgSize = ComputeDictInt32FieldSize([aKey intValue], kMapKeyFieldNumber, keyDataType);
3209    msgSize += ComputeDictUInt32FieldSize([aValue unsignedIntValue], kMapValueFieldNumber, valueDataType);
3210    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
3211  }
3212  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
3213  result += tagSize * count;
3214  return result;
3215}
3216
3217- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
3218                         asField:(GPBFieldDescriptor *)field {
3219  GPBDataType valueDataType = GPBGetFieldDataType(field);
3220  GPBDataType keyDataType = field.mapKeyDataType;
3221  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
3222  NSDictionary *internal = _dictionary;
3223  NSEnumerator *keys = [internal keyEnumerator];
3224  NSNumber *aKey;
3225  while ((aKey = [keys nextObject])) {
3226    NSNumber *aValue = internal[aKey];
3227    [outputStream writeInt32NoTag:tag];
3228    // Write the size of the message.
3229    int32_t unwrappedKey = [aKey intValue];
3230    uint32_t unwrappedValue = [aValue unsignedIntValue];
3231    size_t msgSize = ComputeDictInt32FieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
3232    msgSize += ComputeDictUInt32FieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
3233    [outputStream writeInt32NoTag:(int32_t)msgSize];
3234    // Write the fields.
3235    WriteDictInt32Field(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
3236    WriteDictUInt32Field(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
3237  }
3238}
3239
3240- (void)setGPBGenericValue:(GPBGenericValue *)value
3241     forGPBGenericValueKey:(GPBGenericValue *)key {
3242  [_dictionary setObject:@(value->valueUInt32) forKey:@(key->valueInt32)];
3243}
3244
3245- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
3246  [self enumerateKeysAndUInt32sUsingBlock:^(int32_t key, uint32_t value, __unused BOOL *stop) {
3247      block([NSString stringWithFormat:@"%d", key], [NSString stringWithFormat:@"%u", value]);
3248  }];
3249}
3250
3251- (BOOL)getUInt32:(nullable uint32_t *)value forKey:(int32_t)key {
3252  NSNumber *wrapped = [_dictionary objectForKey:@(key)];
3253  if (wrapped && value) {
3254    *value = [wrapped unsignedIntValue];
3255  }
3256  return (wrapped != NULL);
3257}
3258
3259- (void)addEntriesFromDictionary:(GPBInt32UInt32Dictionary *)otherDictionary {
3260  if (otherDictionary) {
3261    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
3262    if (_autocreator) {
3263      GPBAutocreatedDictionaryModified(_autocreator, self);
3264    }
3265  }
3266}
3267
3268- (void)setUInt32:(uint32_t)value forKey:(int32_t)key {
3269  [_dictionary setObject:@(value) forKey:@(key)];
3270  if (_autocreator) {
3271    GPBAutocreatedDictionaryModified(_autocreator, self);
3272  }
3273}
3274
3275- (void)removeUInt32ForKey:(int32_t)aKey {
3276  [_dictionary removeObjectForKey:@(aKey)];
3277}
3278
3279- (void)removeAll {
3280  [_dictionary removeAllObjects];
3281}
3282
3283@end
3284
3285#pragma mark - Int32 -> Int32
3286
3287@implementation GPBInt32Int32Dictionary {
3288 @package
3289  NSMutableDictionary *_dictionary;
3290}
3291
3292- (instancetype)init {
3293  return [self initWithInt32s:NULL forKeys:NULL count:0];
3294}
3295
3296- (instancetype)initWithInt32s:(const int32_t [])values
3297                       forKeys:(const int32_t [])keys
3298                         count:(NSUInteger)count {
3299  self = [super init];
3300  if (self) {
3301    _dictionary = [[NSMutableDictionary alloc] init];
3302    if (count && values && keys) {
3303      for (NSUInteger i = 0; i < count; ++i) {
3304        [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
3305      }
3306    }
3307  }
3308  return self;
3309}
3310
3311- (instancetype)initWithDictionary:(GPBInt32Int32Dictionary *)dictionary {
3312  self = [self initWithInt32s:NULL forKeys:NULL count:0];
3313  if (self) {
3314    if (dictionary) {
3315      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
3316    }
3317  }
3318  return self;
3319}
3320
3321- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
3322  return [self initWithInt32s:NULL forKeys:NULL count:0];
3323}
3324
3325- (void)dealloc {
3326  NSAssert(!_autocreator,
3327           @"%@: Autocreator must be cleared before release, autocreator: %@",
3328           [self class], _autocreator);
3329  [_dictionary release];
3330  [super dealloc];
3331}
3332
3333- (instancetype)copyWithZone:(NSZone *)zone {
3334  return [[GPBInt32Int32Dictionary allocWithZone:zone] initWithDictionary:self];
3335}
3336
3337- (BOOL)isEqual:(id)other {
3338  if (self == other) {
3339    return YES;
3340  }
3341  if (![other isKindOfClass:[GPBInt32Int32Dictionary class]]) {
3342    return NO;
3343  }
3344  GPBInt32Int32Dictionary *otherDictionary = other;
3345  return [_dictionary isEqual:otherDictionary->_dictionary];
3346}
3347
3348- (NSUInteger)hash {
3349  return _dictionary.count;
3350}
3351
3352- (NSString *)description {
3353  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
3354}
3355
3356- (NSUInteger)count {
3357  return _dictionary.count;
3358}
3359
3360- (void)enumerateKeysAndInt32sUsingBlock:
3361    (void (NS_NOESCAPE ^)(int32_t key, int32_t value, BOOL *stop))block {
3362  BOOL stop = NO;
3363  NSDictionary *internal = _dictionary;
3364  NSEnumerator *keys = [internal keyEnumerator];
3365  NSNumber *aKey;
3366  while ((aKey = [keys nextObject])) {
3367    NSNumber *aValue = internal[aKey];
3368    block([aKey intValue], [aValue intValue], &stop);
3369    if (stop) {
3370      break;
3371    }
3372  }
3373}
3374
3375- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
3376  NSDictionary *internal = _dictionary;
3377  NSUInteger count = internal.count;
3378  if (count == 0) {
3379    return 0;
3380  }
3381
3382  GPBDataType valueDataType = GPBGetFieldDataType(field);
3383  GPBDataType keyDataType = field.mapKeyDataType;
3384  size_t result = 0;
3385  NSEnumerator *keys = [internal keyEnumerator];
3386  NSNumber *aKey;
3387  while ((aKey = [keys nextObject])) {
3388    NSNumber *aValue = internal[aKey];
3389    size_t msgSize = ComputeDictInt32FieldSize([aKey intValue], kMapKeyFieldNumber, keyDataType);
3390    msgSize += ComputeDictInt32FieldSize([aValue intValue], kMapValueFieldNumber, valueDataType);
3391    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
3392  }
3393  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
3394  result += tagSize * count;
3395  return result;
3396}
3397
3398- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
3399                         asField:(GPBFieldDescriptor *)field {
3400  GPBDataType valueDataType = GPBGetFieldDataType(field);
3401  GPBDataType keyDataType = field.mapKeyDataType;
3402  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
3403  NSDictionary *internal = _dictionary;
3404  NSEnumerator *keys = [internal keyEnumerator];
3405  NSNumber *aKey;
3406  while ((aKey = [keys nextObject])) {
3407    NSNumber *aValue = internal[aKey];
3408    [outputStream writeInt32NoTag:tag];
3409    // Write the size of the message.
3410    int32_t unwrappedKey = [aKey intValue];
3411    int32_t unwrappedValue = [aValue intValue];
3412    size_t msgSize = ComputeDictInt32FieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
3413    msgSize += ComputeDictInt32FieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
3414    [outputStream writeInt32NoTag:(int32_t)msgSize];
3415    // Write the fields.
3416    WriteDictInt32Field(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
3417    WriteDictInt32Field(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
3418  }
3419}
3420
3421- (void)setGPBGenericValue:(GPBGenericValue *)value
3422     forGPBGenericValueKey:(GPBGenericValue *)key {
3423  [_dictionary setObject:@(value->valueInt32) forKey:@(key->valueInt32)];
3424}
3425
3426- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
3427  [self enumerateKeysAndInt32sUsingBlock:^(int32_t key, int32_t value, __unused BOOL *stop) {
3428      block([NSString stringWithFormat:@"%d", key], [NSString stringWithFormat:@"%d", value]);
3429  }];
3430}
3431
3432- (BOOL)getInt32:(nullable int32_t *)value forKey:(int32_t)key {
3433  NSNumber *wrapped = [_dictionary objectForKey:@(key)];
3434  if (wrapped && value) {
3435    *value = [wrapped intValue];
3436  }
3437  return (wrapped != NULL);
3438}
3439
3440- (void)addEntriesFromDictionary:(GPBInt32Int32Dictionary *)otherDictionary {
3441  if (otherDictionary) {
3442    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
3443    if (_autocreator) {
3444      GPBAutocreatedDictionaryModified(_autocreator, self);
3445    }
3446  }
3447}
3448
3449- (void)setInt32:(int32_t)value forKey:(int32_t)key {
3450  [_dictionary setObject:@(value) forKey:@(key)];
3451  if (_autocreator) {
3452    GPBAutocreatedDictionaryModified(_autocreator, self);
3453  }
3454}
3455
3456- (void)removeInt32ForKey:(int32_t)aKey {
3457  [_dictionary removeObjectForKey:@(aKey)];
3458}
3459
3460- (void)removeAll {
3461  [_dictionary removeAllObjects];
3462}
3463
3464@end
3465
3466#pragma mark - Int32 -> UInt64
3467
3468@implementation GPBInt32UInt64Dictionary {
3469 @package
3470  NSMutableDictionary *_dictionary;
3471}
3472
3473- (instancetype)init {
3474  return [self initWithUInt64s:NULL forKeys:NULL count:0];
3475}
3476
3477- (instancetype)initWithUInt64s:(const uint64_t [])values
3478                        forKeys:(const int32_t [])keys
3479                          count:(NSUInteger)count {
3480  self = [super init];
3481  if (self) {
3482    _dictionary = [[NSMutableDictionary alloc] init];
3483    if (count && values && keys) {
3484      for (NSUInteger i = 0; i < count; ++i) {
3485        [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
3486      }
3487    }
3488  }
3489  return self;
3490}
3491
3492- (instancetype)initWithDictionary:(GPBInt32UInt64Dictionary *)dictionary {
3493  self = [self initWithUInt64s:NULL forKeys:NULL count:0];
3494  if (self) {
3495    if (dictionary) {
3496      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
3497    }
3498  }
3499  return self;
3500}
3501
3502- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
3503  return [self initWithUInt64s:NULL forKeys:NULL count:0];
3504}
3505
3506- (void)dealloc {
3507  NSAssert(!_autocreator,
3508           @"%@: Autocreator must be cleared before release, autocreator: %@",
3509           [self class], _autocreator);
3510  [_dictionary release];
3511  [super dealloc];
3512}
3513
3514- (instancetype)copyWithZone:(NSZone *)zone {
3515  return [[GPBInt32UInt64Dictionary allocWithZone:zone] initWithDictionary:self];
3516}
3517
3518- (BOOL)isEqual:(id)other {
3519  if (self == other) {
3520    return YES;
3521  }
3522  if (![other isKindOfClass:[GPBInt32UInt64Dictionary class]]) {
3523    return NO;
3524  }
3525  GPBInt32UInt64Dictionary *otherDictionary = other;
3526  return [_dictionary isEqual:otherDictionary->_dictionary];
3527}
3528
3529- (NSUInteger)hash {
3530  return _dictionary.count;
3531}
3532
3533- (NSString *)description {
3534  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
3535}
3536
3537- (NSUInteger)count {
3538  return _dictionary.count;
3539}
3540
3541- (void)enumerateKeysAndUInt64sUsingBlock:
3542    (void (NS_NOESCAPE ^)(int32_t key, uint64_t value, BOOL *stop))block {
3543  BOOL stop = NO;
3544  NSDictionary *internal = _dictionary;
3545  NSEnumerator *keys = [internal keyEnumerator];
3546  NSNumber *aKey;
3547  while ((aKey = [keys nextObject])) {
3548    NSNumber *aValue = internal[aKey];
3549    block([aKey intValue], [aValue unsignedLongLongValue], &stop);
3550    if (stop) {
3551      break;
3552    }
3553  }
3554}
3555
3556- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
3557  NSDictionary *internal = _dictionary;
3558  NSUInteger count = internal.count;
3559  if (count == 0) {
3560    return 0;
3561  }
3562
3563  GPBDataType valueDataType = GPBGetFieldDataType(field);
3564  GPBDataType keyDataType = field.mapKeyDataType;
3565  size_t result = 0;
3566  NSEnumerator *keys = [internal keyEnumerator];
3567  NSNumber *aKey;
3568  while ((aKey = [keys nextObject])) {
3569    NSNumber *aValue = internal[aKey];
3570    size_t msgSize = ComputeDictInt32FieldSize([aKey intValue], kMapKeyFieldNumber, keyDataType);
3571    msgSize += ComputeDictUInt64FieldSize([aValue unsignedLongLongValue], kMapValueFieldNumber, valueDataType);
3572    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
3573  }
3574  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
3575  result += tagSize * count;
3576  return result;
3577}
3578
3579- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
3580                         asField:(GPBFieldDescriptor *)field {
3581  GPBDataType valueDataType = GPBGetFieldDataType(field);
3582  GPBDataType keyDataType = field.mapKeyDataType;
3583  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
3584  NSDictionary *internal = _dictionary;
3585  NSEnumerator *keys = [internal keyEnumerator];
3586  NSNumber *aKey;
3587  while ((aKey = [keys nextObject])) {
3588    NSNumber *aValue = internal[aKey];
3589    [outputStream writeInt32NoTag:tag];
3590    // Write the size of the message.
3591    int32_t unwrappedKey = [aKey intValue];
3592    uint64_t unwrappedValue = [aValue unsignedLongLongValue];
3593    size_t msgSize = ComputeDictInt32FieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
3594    msgSize += ComputeDictUInt64FieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
3595    [outputStream writeInt32NoTag:(int32_t)msgSize];
3596    // Write the fields.
3597    WriteDictInt32Field(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
3598    WriteDictUInt64Field(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
3599  }
3600}
3601
3602- (void)setGPBGenericValue:(GPBGenericValue *)value
3603     forGPBGenericValueKey:(GPBGenericValue *)key {
3604  [_dictionary setObject:@(value->valueUInt64) forKey:@(key->valueInt32)];
3605}
3606
3607- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
3608  [self enumerateKeysAndUInt64sUsingBlock:^(int32_t key, uint64_t value, __unused BOOL *stop) {
3609      block([NSString stringWithFormat:@"%d", key], [NSString stringWithFormat:@"%llu", value]);
3610  }];
3611}
3612
3613- (BOOL)getUInt64:(nullable uint64_t *)value forKey:(int32_t)key {
3614  NSNumber *wrapped = [_dictionary objectForKey:@(key)];
3615  if (wrapped && value) {
3616    *value = [wrapped unsignedLongLongValue];
3617  }
3618  return (wrapped != NULL);
3619}
3620
3621- (void)addEntriesFromDictionary:(GPBInt32UInt64Dictionary *)otherDictionary {
3622  if (otherDictionary) {
3623    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
3624    if (_autocreator) {
3625      GPBAutocreatedDictionaryModified(_autocreator, self);
3626    }
3627  }
3628}
3629
3630- (void)setUInt64:(uint64_t)value forKey:(int32_t)key {
3631  [_dictionary setObject:@(value) forKey:@(key)];
3632  if (_autocreator) {
3633    GPBAutocreatedDictionaryModified(_autocreator, self);
3634  }
3635}
3636
3637- (void)removeUInt64ForKey:(int32_t)aKey {
3638  [_dictionary removeObjectForKey:@(aKey)];
3639}
3640
3641- (void)removeAll {
3642  [_dictionary removeAllObjects];
3643}
3644
3645@end
3646
3647#pragma mark - Int32 -> Int64
3648
3649@implementation GPBInt32Int64Dictionary {
3650 @package
3651  NSMutableDictionary *_dictionary;
3652}
3653
3654- (instancetype)init {
3655  return [self initWithInt64s:NULL forKeys:NULL count:0];
3656}
3657
3658- (instancetype)initWithInt64s:(const int64_t [])values
3659                       forKeys:(const int32_t [])keys
3660                         count:(NSUInteger)count {
3661  self = [super init];
3662  if (self) {
3663    _dictionary = [[NSMutableDictionary alloc] init];
3664    if (count && values && keys) {
3665      for (NSUInteger i = 0; i < count; ++i) {
3666        [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
3667      }
3668    }
3669  }
3670  return self;
3671}
3672
3673- (instancetype)initWithDictionary:(GPBInt32Int64Dictionary *)dictionary {
3674  self = [self initWithInt64s:NULL forKeys:NULL count:0];
3675  if (self) {
3676    if (dictionary) {
3677      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
3678    }
3679  }
3680  return self;
3681}
3682
3683- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
3684  return [self initWithInt64s:NULL forKeys:NULL count:0];
3685}
3686
3687- (void)dealloc {
3688  NSAssert(!_autocreator,
3689           @"%@: Autocreator must be cleared before release, autocreator: %@",
3690           [self class], _autocreator);
3691  [_dictionary release];
3692  [super dealloc];
3693}
3694
3695- (instancetype)copyWithZone:(NSZone *)zone {
3696  return [[GPBInt32Int64Dictionary allocWithZone:zone] initWithDictionary:self];
3697}
3698
3699- (BOOL)isEqual:(id)other {
3700  if (self == other) {
3701    return YES;
3702  }
3703  if (![other isKindOfClass:[GPBInt32Int64Dictionary class]]) {
3704    return NO;
3705  }
3706  GPBInt32Int64Dictionary *otherDictionary = other;
3707  return [_dictionary isEqual:otherDictionary->_dictionary];
3708}
3709
3710- (NSUInteger)hash {
3711  return _dictionary.count;
3712}
3713
3714- (NSString *)description {
3715  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
3716}
3717
3718- (NSUInteger)count {
3719  return _dictionary.count;
3720}
3721
3722- (void)enumerateKeysAndInt64sUsingBlock:
3723    (void (NS_NOESCAPE ^)(int32_t key, int64_t value, BOOL *stop))block {
3724  BOOL stop = NO;
3725  NSDictionary *internal = _dictionary;
3726  NSEnumerator *keys = [internal keyEnumerator];
3727  NSNumber *aKey;
3728  while ((aKey = [keys nextObject])) {
3729    NSNumber *aValue = internal[aKey];
3730    block([aKey intValue], [aValue longLongValue], &stop);
3731    if (stop) {
3732      break;
3733    }
3734  }
3735}
3736
3737- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
3738  NSDictionary *internal = _dictionary;
3739  NSUInteger count = internal.count;
3740  if (count == 0) {
3741    return 0;
3742  }
3743
3744  GPBDataType valueDataType = GPBGetFieldDataType(field);
3745  GPBDataType keyDataType = field.mapKeyDataType;
3746  size_t result = 0;
3747  NSEnumerator *keys = [internal keyEnumerator];
3748  NSNumber *aKey;
3749  while ((aKey = [keys nextObject])) {
3750    NSNumber *aValue = internal[aKey];
3751    size_t msgSize = ComputeDictInt32FieldSize([aKey intValue], kMapKeyFieldNumber, keyDataType);
3752    msgSize += ComputeDictInt64FieldSize([aValue longLongValue], kMapValueFieldNumber, valueDataType);
3753    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
3754  }
3755  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
3756  result += tagSize * count;
3757  return result;
3758}
3759
3760- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
3761                         asField:(GPBFieldDescriptor *)field {
3762  GPBDataType valueDataType = GPBGetFieldDataType(field);
3763  GPBDataType keyDataType = field.mapKeyDataType;
3764  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
3765  NSDictionary *internal = _dictionary;
3766  NSEnumerator *keys = [internal keyEnumerator];
3767  NSNumber *aKey;
3768  while ((aKey = [keys nextObject])) {
3769    NSNumber *aValue = internal[aKey];
3770    [outputStream writeInt32NoTag:tag];
3771    // Write the size of the message.
3772    int32_t unwrappedKey = [aKey intValue];
3773    int64_t unwrappedValue = [aValue longLongValue];
3774    size_t msgSize = ComputeDictInt32FieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
3775    msgSize += ComputeDictInt64FieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
3776    [outputStream writeInt32NoTag:(int32_t)msgSize];
3777    // Write the fields.
3778    WriteDictInt32Field(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
3779    WriteDictInt64Field(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
3780  }
3781}
3782
3783- (void)setGPBGenericValue:(GPBGenericValue *)value
3784     forGPBGenericValueKey:(GPBGenericValue *)key {
3785  [_dictionary setObject:@(value->valueInt64) forKey:@(key->valueInt32)];
3786}
3787
3788- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
3789  [self enumerateKeysAndInt64sUsingBlock:^(int32_t key, int64_t value, __unused BOOL *stop) {
3790      block([NSString stringWithFormat:@"%d", key], [NSString stringWithFormat:@"%lld", value]);
3791  }];
3792}
3793
3794- (BOOL)getInt64:(nullable int64_t *)value forKey:(int32_t)key {
3795  NSNumber *wrapped = [_dictionary objectForKey:@(key)];
3796  if (wrapped && value) {
3797    *value = [wrapped longLongValue];
3798  }
3799  return (wrapped != NULL);
3800}
3801
3802- (void)addEntriesFromDictionary:(GPBInt32Int64Dictionary *)otherDictionary {
3803  if (otherDictionary) {
3804    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
3805    if (_autocreator) {
3806      GPBAutocreatedDictionaryModified(_autocreator, self);
3807    }
3808  }
3809}
3810
3811- (void)setInt64:(int64_t)value forKey:(int32_t)key {
3812  [_dictionary setObject:@(value) forKey:@(key)];
3813  if (_autocreator) {
3814    GPBAutocreatedDictionaryModified(_autocreator, self);
3815  }
3816}
3817
3818- (void)removeInt64ForKey:(int32_t)aKey {
3819  [_dictionary removeObjectForKey:@(aKey)];
3820}
3821
3822- (void)removeAll {
3823  [_dictionary removeAllObjects];
3824}
3825
3826@end
3827
3828#pragma mark - Int32 -> Bool
3829
3830@implementation GPBInt32BoolDictionary {
3831 @package
3832  NSMutableDictionary *_dictionary;
3833}
3834
3835- (instancetype)init {
3836  return [self initWithBools:NULL forKeys:NULL count:0];
3837}
3838
3839- (instancetype)initWithBools:(const BOOL [])values
3840                      forKeys:(const int32_t [])keys
3841                        count:(NSUInteger)count {
3842  self = [super init];
3843  if (self) {
3844    _dictionary = [[NSMutableDictionary alloc] init];
3845    if (count && values && keys) {
3846      for (NSUInteger i = 0; i < count; ++i) {
3847        [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
3848      }
3849    }
3850  }
3851  return self;
3852}
3853
3854- (instancetype)initWithDictionary:(GPBInt32BoolDictionary *)dictionary {
3855  self = [self initWithBools:NULL forKeys:NULL count:0];
3856  if (self) {
3857    if (dictionary) {
3858      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
3859    }
3860  }
3861  return self;
3862}
3863
3864- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
3865  return [self initWithBools:NULL forKeys:NULL count:0];
3866}
3867
3868- (void)dealloc {
3869  NSAssert(!_autocreator,
3870           @"%@: Autocreator must be cleared before release, autocreator: %@",
3871           [self class], _autocreator);
3872  [_dictionary release];
3873  [super dealloc];
3874}
3875
3876- (instancetype)copyWithZone:(NSZone *)zone {
3877  return [[GPBInt32BoolDictionary allocWithZone:zone] initWithDictionary:self];
3878}
3879
3880- (BOOL)isEqual:(id)other {
3881  if (self == other) {
3882    return YES;
3883  }
3884  if (![other isKindOfClass:[GPBInt32BoolDictionary class]]) {
3885    return NO;
3886  }
3887  GPBInt32BoolDictionary *otherDictionary = other;
3888  return [_dictionary isEqual:otherDictionary->_dictionary];
3889}
3890
3891- (NSUInteger)hash {
3892  return _dictionary.count;
3893}
3894
3895- (NSString *)description {
3896  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
3897}
3898
3899- (NSUInteger)count {
3900  return _dictionary.count;
3901}
3902
3903- (void)enumerateKeysAndBoolsUsingBlock:
3904    (void (NS_NOESCAPE ^)(int32_t key, BOOL value, BOOL *stop))block {
3905  BOOL stop = NO;
3906  NSDictionary *internal = _dictionary;
3907  NSEnumerator *keys = [internal keyEnumerator];
3908  NSNumber *aKey;
3909  while ((aKey = [keys nextObject])) {
3910    NSNumber *aValue = internal[aKey];
3911    block([aKey intValue], [aValue boolValue], &stop);
3912    if (stop) {
3913      break;
3914    }
3915  }
3916}
3917
3918- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
3919  NSDictionary *internal = _dictionary;
3920  NSUInteger count = internal.count;
3921  if (count == 0) {
3922    return 0;
3923  }
3924
3925  GPBDataType valueDataType = GPBGetFieldDataType(field);
3926  GPBDataType keyDataType = field.mapKeyDataType;
3927  size_t result = 0;
3928  NSEnumerator *keys = [internal keyEnumerator];
3929  NSNumber *aKey;
3930  while ((aKey = [keys nextObject])) {
3931    NSNumber *aValue = internal[aKey];
3932    size_t msgSize = ComputeDictInt32FieldSize([aKey intValue], kMapKeyFieldNumber, keyDataType);
3933    msgSize += ComputeDictBoolFieldSize([aValue boolValue], kMapValueFieldNumber, valueDataType);
3934    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
3935  }
3936  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
3937  result += tagSize * count;
3938  return result;
3939}
3940
3941- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
3942                         asField:(GPBFieldDescriptor *)field {
3943  GPBDataType valueDataType = GPBGetFieldDataType(field);
3944  GPBDataType keyDataType = field.mapKeyDataType;
3945  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
3946  NSDictionary *internal = _dictionary;
3947  NSEnumerator *keys = [internal keyEnumerator];
3948  NSNumber *aKey;
3949  while ((aKey = [keys nextObject])) {
3950    NSNumber *aValue = internal[aKey];
3951    [outputStream writeInt32NoTag:tag];
3952    // Write the size of the message.
3953    int32_t unwrappedKey = [aKey intValue];
3954    BOOL unwrappedValue = [aValue boolValue];
3955    size_t msgSize = ComputeDictInt32FieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
3956    msgSize += ComputeDictBoolFieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
3957    [outputStream writeInt32NoTag:(int32_t)msgSize];
3958    // Write the fields.
3959    WriteDictInt32Field(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
3960    WriteDictBoolField(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
3961  }
3962}
3963
3964- (void)setGPBGenericValue:(GPBGenericValue *)value
3965     forGPBGenericValueKey:(GPBGenericValue *)key {
3966  [_dictionary setObject:@(value->valueBool) forKey:@(key->valueInt32)];
3967}
3968
3969- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
3970  [self enumerateKeysAndBoolsUsingBlock:^(int32_t key, BOOL value, __unused BOOL *stop) {
3971      block([NSString stringWithFormat:@"%d", key], (value ? @"true" : @"false"));
3972  }];
3973}
3974
3975- (BOOL)getBool:(nullable BOOL *)value forKey:(int32_t)key {
3976  NSNumber *wrapped = [_dictionary objectForKey:@(key)];
3977  if (wrapped && value) {
3978    *value = [wrapped boolValue];
3979  }
3980  return (wrapped != NULL);
3981}
3982
3983- (void)addEntriesFromDictionary:(GPBInt32BoolDictionary *)otherDictionary {
3984  if (otherDictionary) {
3985    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
3986    if (_autocreator) {
3987      GPBAutocreatedDictionaryModified(_autocreator, self);
3988    }
3989  }
3990}
3991
3992- (void)setBool:(BOOL)value forKey:(int32_t)key {
3993  [_dictionary setObject:@(value) forKey:@(key)];
3994  if (_autocreator) {
3995    GPBAutocreatedDictionaryModified(_autocreator, self);
3996  }
3997}
3998
3999- (void)removeBoolForKey:(int32_t)aKey {
4000  [_dictionary removeObjectForKey:@(aKey)];
4001}
4002
4003- (void)removeAll {
4004  [_dictionary removeAllObjects];
4005}
4006
4007@end
4008
4009#pragma mark - Int32 -> Float
4010
4011@implementation GPBInt32FloatDictionary {
4012 @package
4013  NSMutableDictionary *_dictionary;
4014}
4015
4016- (instancetype)init {
4017  return [self initWithFloats:NULL forKeys:NULL count:0];
4018}
4019
4020- (instancetype)initWithFloats:(const float [])values
4021                       forKeys:(const int32_t [])keys
4022                         count:(NSUInteger)count {
4023  self = [super init];
4024  if (self) {
4025    _dictionary = [[NSMutableDictionary alloc] init];
4026    if (count && values && keys) {
4027      for (NSUInteger i = 0; i < count; ++i) {
4028        [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
4029      }
4030    }
4031  }
4032  return self;
4033}
4034
4035- (instancetype)initWithDictionary:(GPBInt32FloatDictionary *)dictionary {
4036  self = [self initWithFloats:NULL forKeys:NULL count:0];
4037  if (self) {
4038    if (dictionary) {
4039      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
4040    }
4041  }
4042  return self;
4043}
4044
4045- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
4046  return [self initWithFloats:NULL forKeys:NULL count:0];
4047}
4048
4049- (void)dealloc {
4050  NSAssert(!_autocreator,
4051           @"%@: Autocreator must be cleared before release, autocreator: %@",
4052           [self class], _autocreator);
4053  [_dictionary release];
4054  [super dealloc];
4055}
4056
4057- (instancetype)copyWithZone:(NSZone *)zone {
4058  return [[GPBInt32FloatDictionary allocWithZone:zone] initWithDictionary:self];
4059}
4060
4061- (BOOL)isEqual:(id)other {
4062  if (self == other) {
4063    return YES;
4064  }
4065  if (![other isKindOfClass:[GPBInt32FloatDictionary class]]) {
4066    return NO;
4067  }
4068  GPBInt32FloatDictionary *otherDictionary = other;
4069  return [_dictionary isEqual:otherDictionary->_dictionary];
4070}
4071
4072- (NSUInteger)hash {
4073  return _dictionary.count;
4074}
4075
4076- (NSString *)description {
4077  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
4078}
4079
4080- (NSUInteger)count {
4081  return _dictionary.count;
4082}
4083
4084- (void)enumerateKeysAndFloatsUsingBlock:
4085    (void (NS_NOESCAPE ^)(int32_t key, float value, BOOL *stop))block {
4086  BOOL stop = NO;
4087  NSDictionary *internal = _dictionary;
4088  NSEnumerator *keys = [internal keyEnumerator];
4089  NSNumber *aKey;
4090  while ((aKey = [keys nextObject])) {
4091    NSNumber *aValue = internal[aKey];
4092    block([aKey intValue], [aValue floatValue], &stop);
4093    if (stop) {
4094      break;
4095    }
4096  }
4097}
4098
4099- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
4100  NSDictionary *internal = _dictionary;
4101  NSUInteger count = internal.count;
4102  if (count == 0) {
4103    return 0;
4104  }
4105
4106  GPBDataType valueDataType = GPBGetFieldDataType(field);
4107  GPBDataType keyDataType = field.mapKeyDataType;
4108  size_t result = 0;
4109  NSEnumerator *keys = [internal keyEnumerator];
4110  NSNumber *aKey;
4111  while ((aKey = [keys nextObject])) {
4112    NSNumber *aValue = internal[aKey];
4113    size_t msgSize = ComputeDictInt32FieldSize([aKey intValue], kMapKeyFieldNumber, keyDataType);
4114    msgSize += ComputeDictFloatFieldSize([aValue floatValue], kMapValueFieldNumber, valueDataType);
4115    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
4116  }
4117  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
4118  result += tagSize * count;
4119  return result;
4120}
4121
4122- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
4123                         asField:(GPBFieldDescriptor *)field {
4124  GPBDataType valueDataType = GPBGetFieldDataType(field);
4125  GPBDataType keyDataType = field.mapKeyDataType;
4126  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
4127  NSDictionary *internal = _dictionary;
4128  NSEnumerator *keys = [internal keyEnumerator];
4129  NSNumber *aKey;
4130  while ((aKey = [keys nextObject])) {
4131    NSNumber *aValue = internal[aKey];
4132    [outputStream writeInt32NoTag:tag];
4133    // Write the size of the message.
4134    int32_t unwrappedKey = [aKey intValue];
4135    float unwrappedValue = [aValue floatValue];
4136    size_t msgSize = ComputeDictInt32FieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
4137    msgSize += ComputeDictFloatFieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
4138    [outputStream writeInt32NoTag:(int32_t)msgSize];
4139    // Write the fields.
4140    WriteDictInt32Field(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
4141    WriteDictFloatField(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
4142  }
4143}
4144
4145- (void)setGPBGenericValue:(GPBGenericValue *)value
4146     forGPBGenericValueKey:(GPBGenericValue *)key {
4147  [_dictionary setObject:@(value->valueFloat) forKey:@(key->valueInt32)];
4148}
4149
4150- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
4151  [self enumerateKeysAndFloatsUsingBlock:^(int32_t key, float value, __unused BOOL *stop) {
4152      block([NSString stringWithFormat:@"%d", key], [NSString stringWithFormat:@"%.*g", FLT_DIG, value]);
4153  }];
4154}
4155
4156- (BOOL)getFloat:(nullable float *)value forKey:(int32_t)key {
4157  NSNumber *wrapped = [_dictionary objectForKey:@(key)];
4158  if (wrapped && value) {
4159    *value = [wrapped floatValue];
4160  }
4161  return (wrapped != NULL);
4162}
4163
4164- (void)addEntriesFromDictionary:(GPBInt32FloatDictionary *)otherDictionary {
4165  if (otherDictionary) {
4166    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
4167    if (_autocreator) {
4168      GPBAutocreatedDictionaryModified(_autocreator, self);
4169    }
4170  }
4171}
4172
4173- (void)setFloat:(float)value forKey:(int32_t)key {
4174  [_dictionary setObject:@(value) forKey:@(key)];
4175  if (_autocreator) {
4176    GPBAutocreatedDictionaryModified(_autocreator, self);
4177  }
4178}
4179
4180- (void)removeFloatForKey:(int32_t)aKey {
4181  [_dictionary removeObjectForKey:@(aKey)];
4182}
4183
4184- (void)removeAll {
4185  [_dictionary removeAllObjects];
4186}
4187
4188@end
4189
4190#pragma mark - Int32 -> Double
4191
4192@implementation GPBInt32DoubleDictionary {
4193 @package
4194  NSMutableDictionary *_dictionary;
4195}
4196
4197- (instancetype)init {
4198  return [self initWithDoubles:NULL forKeys:NULL count:0];
4199}
4200
4201- (instancetype)initWithDoubles:(const double [])values
4202                        forKeys:(const int32_t [])keys
4203                          count:(NSUInteger)count {
4204  self = [super init];
4205  if (self) {
4206    _dictionary = [[NSMutableDictionary alloc] init];
4207    if (count && values && keys) {
4208      for (NSUInteger i = 0; i < count; ++i) {
4209        [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
4210      }
4211    }
4212  }
4213  return self;
4214}
4215
4216- (instancetype)initWithDictionary:(GPBInt32DoubleDictionary *)dictionary {
4217  self = [self initWithDoubles:NULL forKeys:NULL count:0];
4218  if (self) {
4219    if (dictionary) {
4220      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
4221    }
4222  }
4223  return self;
4224}
4225
4226- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
4227  return [self initWithDoubles:NULL forKeys:NULL count:0];
4228}
4229
4230- (void)dealloc {
4231  NSAssert(!_autocreator,
4232           @"%@: Autocreator must be cleared before release, autocreator: %@",
4233           [self class], _autocreator);
4234  [_dictionary release];
4235  [super dealloc];
4236}
4237
4238- (instancetype)copyWithZone:(NSZone *)zone {
4239  return [[GPBInt32DoubleDictionary allocWithZone:zone] initWithDictionary:self];
4240}
4241
4242- (BOOL)isEqual:(id)other {
4243  if (self == other) {
4244    return YES;
4245  }
4246  if (![other isKindOfClass:[GPBInt32DoubleDictionary class]]) {
4247    return NO;
4248  }
4249  GPBInt32DoubleDictionary *otherDictionary = other;
4250  return [_dictionary isEqual:otherDictionary->_dictionary];
4251}
4252
4253- (NSUInteger)hash {
4254  return _dictionary.count;
4255}
4256
4257- (NSString *)description {
4258  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
4259}
4260
4261- (NSUInteger)count {
4262  return _dictionary.count;
4263}
4264
4265- (void)enumerateKeysAndDoublesUsingBlock:
4266    (void (NS_NOESCAPE ^)(int32_t key, double value, BOOL *stop))block {
4267  BOOL stop = NO;
4268  NSDictionary *internal = _dictionary;
4269  NSEnumerator *keys = [internal keyEnumerator];
4270  NSNumber *aKey;
4271  while ((aKey = [keys nextObject])) {
4272    NSNumber *aValue = internal[aKey];
4273    block([aKey intValue], [aValue doubleValue], &stop);
4274    if (stop) {
4275      break;
4276    }
4277  }
4278}
4279
4280- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
4281  NSDictionary *internal = _dictionary;
4282  NSUInteger count = internal.count;
4283  if (count == 0) {
4284    return 0;
4285  }
4286
4287  GPBDataType valueDataType = GPBGetFieldDataType(field);
4288  GPBDataType keyDataType = field.mapKeyDataType;
4289  size_t result = 0;
4290  NSEnumerator *keys = [internal keyEnumerator];
4291  NSNumber *aKey;
4292  while ((aKey = [keys nextObject])) {
4293    NSNumber *aValue = internal[aKey];
4294    size_t msgSize = ComputeDictInt32FieldSize([aKey intValue], kMapKeyFieldNumber, keyDataType);
4295    msgSize += ComputeDictDoubleFieldSize([aValue doubleValue], kMapValueFieldNumber, valueDataType);
4296    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
4297  }
4298  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
4299  result += tagSize * count;
4300  return result;
4301}
4302
4303- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
4304                         asField:(GPBFieldDescriptor *)field {
4305  GPBDataType valueDataType = GPBGetFieldDataType(field);
4306  GPBDataType keyDataType = field.mapKeyDataType;
4307  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
4308  NSDictionary *internal = _dictionary;
4309  NSEnumerator *keys = [internal keyEnumerator];
4310  NSNumber *aKey;
4311  while ((aKey = [keys nextObject])) {
4312    NSNumber *aValue = internal[aKey];
4313    [outputStream writeInt32NoTag:tag];
4314    // Write the size of the message.
4315    int32_t unwrappedKey = [aKey intValue];
4316    double unwrappedValue = [aValue doubleValue];
4317    size_t msgSize = ComputeDictInt32FieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
4318    msgSize += ComputeDictDoubleFieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
4319    [outputStream writeInt32NoTag:(int32_t)msgSize];
4320    // Write the fields.
4321    WriteDictInt32Field(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
4322    WriteDictDoubleField(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
4323  }
4324}
4325
4326- (void)setGPBGenericValue:(GPBGenericValue *)value
4327     forGPBGenericValueKey:(GPBGenericValue *)key {
4328  [_dictionary setObject:@(value->valueDouble) forKey:@(key->valueInt32)];
4329}
4330
4331- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
4332  [self enumerateKeysAndDoublesUsingBlock:^(int32_t key, double value, __unused BOOL *stop) {
4333      block([NSString stringWithFormat:@"%d", key], [NSString stringWithFormat:@"%.*lg", DBL_DIG, value]);
4334  }];
4335}
4336
4337- (BOOL)getDouble:(nullable double *)value forKey:(int32_t)key {
4338  NSNumber *wrapped = [_dictionary objectForKey:@(key)];
4339  if (wrapped && value) {
4340    *value = [wrapped doubleValue];
4341  }
4342  return (wrapped != NULL);
4343}
4344
4345- (void)addEntriesFromDictionary:(GPBInt32DoubleDictionary *)otherDictionary {
4346  if (otherDictionary) {
4347    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
4348    if (_autocreator) {
4349      GPBAutocreatedDictionaryModified(_autocreator, self);
4350    }
4351  }
4352}
4353
4354- (void)setDouble:(double)value forKey:(int32_t)key {
4355  [_dictionary setObject:@(value) forKey:@(key)];
4356  if (_autocreator) {
4357    GPBAutocreatedDictionaryModified(_autocreator, self);
4358  }
4359}
4360
4361- (void)removeDoubleForKey:(int32_t)aKey {
4362  [_dictionary removeObjectForKey:@(aKey)];
4363}
4364
4365- (void)removeAll {
4366  [_dictionary removeAllObjects];
4367}
4368
4369@end
4370
4371#pragma mark - Int32 -> Enum
4372
4373@implementation GPBInt32EnumDictionary {
4374 @package
4375  NSMutableDictionary *_dictionary;
4376  GPBEnumValidationFunc _validationFunc;
4377}
4378
4379@synthesize validationFunc = _validationFunc;
4380
4381- (instancetype)init {
4382  return [self initWithValidationFunction:NULL rawValues:NULL forKeys:NULL count:0];
4383}
4384
4385- (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func {
4386  return [self initWithValidationFunction:func rawValues:NULL forKeys:NULL count:0];
4387}
4388
4389- (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func
4390                                 rawValues:(const int32_t [])rawValues
4391                                   forKeys:(const int32_t [])keys
4392                                     count:(NSUInteger)count {
4393  self = [super init];
4394  if (self) {
4395    _dictionary = [[NSMutableDictionary alloc] init];
4396    _validationFunc = (func != NULL ? func : DictDefault_IsValidValue);
4397    if (count && rawValues && keys) {
4398      for (NSUInteger i = 0; i < count; ++i) {
4399        [_dictionary setObject:@(rawValues[i]) forKey:@(keys[i])];
4400      }
4401    }
4402  }
4403  return self;
4404}
4405
4406- (instancetype)initWithDictionary:(GPBInt32EnumDictionary *)dictionary {
4407  self = [self initWithValidationFunction:dictionary.validationFunc
4408                                rawValues:NULL
4409                                  forKeys:NULL
4410                                    count:0];
4411  if (self) {
4412    if (dictionary) {
4413      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
4414    }
4415  }
4416  return self;
4417}
4418
4419- (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func
4420                                  capacity:(__unused NSUInteger)numItems {
4421  return [self initWithValidationFunction:func rawValues:NULL forKeys:NULL count:0];
4422}
4423
4424- (void)dealloc {
4425  NSAssert(!_autocreator,
4426           @"%@: Autocreator must be cleared before release, autocreator: %@",
4427           [self class], _autocreator);
4428  [_dictionary release];
4429  [super dealloc];
4430}
4431
4432- (instancetype)copyWithZone:(NSZone *)zone {
4433  return [[GPBInt32EnumDictionary allocWithZone:zone] initWithDictionary:self];
4434}
4435
4436- (BOOL)isEqual:(id)other {
4437  if (self == other) {
4438    return YES;
4439  }
4440  if (![other isKindOfClass:[GPBInt32EnumDictionary class]]) {
4441    return NO;
4442  }
4443  GPBInt32EnumDictionary *otherDictionary = other;
4444  return [_dictionary isEqual:otherDictionary->_dictionary];
4445}
4446
4447- (NSUInteger)hash {
4448  return _dictionary.count;
4449}
4450
4451- (NSString *)description {
4452  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
4453}
4454
4455- (NSUInteger)count {
4456  return _dictionary.count;
4457}
4458
4459- (void)enumerateKeysAndRawValuesUsingBlock:
4460    (void (NS_NOESCAPE ^)(int32_t key, int32_t value, BOOL *stop))block {
4461  BOOL stop = NO;
4462  NSDictionary *internal = _dictionary;
4463  NSEnumerator *keys = [internal keyEnumerator];
4464  NSNumber *aKey;
4465  while ((aKey = [keys nextObject])) {
4466    NSNumber *aValue = internal[aKey];
4467    block([aKey intValue], [aValue intValue], &stop);
4468    if (stop) {
4469      break;
4470    }
4471  }
4472}
4473
4474- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
4475  NSDictionary *internal = _dictionary;
4476  NSUInteger count = internal.count;
4477  if (count == 0) {
4478    return 0;
4479  }
4480
4481  GPBDataType valueDataType = GPBGetFieldDataType(field);
4482  GPBDataType keyDataType = field.mapKeyDataType;
4483  size_t result = 0;
4484  NSEnumerator *keys = [internal keyEnumerator];
4485  NSNumber *aKey;
4486  while ((aKey = [keys nextObject])) {
4487    NSNumber *aValue = internal[aKey];
4488    size_t msgSize = ComputeDictInt32FieldSize([aKey intValue], kMapKeyFieldNumber, keyDataType);
4489    msgSize += ComputeDictEnumFieldSize([aValue intValue], kMapValueFieldNumber, valueDataType);
4490    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
4491  }
4492  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
4493  result += tagSize * count;
4494  return result;
4495}
4496
4497- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
4498                         asField:(GPBFieldDescriptor *)field {
4499  GPBDataType valueDataType = GPBGetFieldDataType(field);
4500  GPBDataType keyDataType = field.mapKeyDataType;
4501  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
4502  NSDictionary *internal = _dictionary;
4503  NSEnumerator *keys = [internal keyEnumerator];
4504  NSNumber *aKey;
4505  while ((aKey = [keys nextObject])) {
4506    NSNumber *aValue = internal[aKey];
4507    [outputStream writeInt32NoTag:tag];
4508    // Write the size of the message.
4509    int32_t unwrappedKey = [aKey intValue];
4510    int32_t unwrappedValue = [aValue intValue];
4511    size_t msgSize = ComputeDictInt32FieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
4512    msgSize += ComputeDictEnumFieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
4513    [outputStream writeInt32NoTag:(int32_t)msgSize];
4514    // Write the fields.
4515    WriteDictInt32Field(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
4516    WriteDictEnumField(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
4517  }
4518}
4519
4520- (NSData *)serializedDataForUnknownValue:(int32_t)value
4521                                   forKey:(GPBGenericValue *)key
4522                              keyDataType:(GPBDataType)keyDataType {
4523  size_t msgSize = ComputeDictInt32FieldSize(key->valueInt32, kMapKeyFieldNumber, keyDataType);
4524  msgSize += ComputeDictEnumFieldSize(value, kMapValueFieldNumber, GPBDataTypeEnum);
4525  NSMutableData *data = [NSMutableData dataWithLength:msgSize];
4526  GPBCodedOutputStream *outputStream = [[GPBCodedOutputStream alloc] initWithData:data];
4527  WriteDictInt32Field(outputStream, key->valueInt32, kMapKeyFieldNumber, keyDataType);
4528  WriteDictEnumField(outputStream, value, kMapValueFieldNumber, GPBDataTypeEnum);
4529  [outputStream flush];
4530  [outputStream release];
4531  return data;
4532}
4533- (void)setGPBGenericValue:(GPBGenericValue *)value
4534     forGPBGenericValueKey:(GPBGenericValue *)key {
4535  [_dictionary setObject:@(value->valueEnum) forKey:@(key->valueInt32)];
4536}
4537
4538- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
4539  [self enumerateKeysAndRawValuesUsingBlock:^(int32_t key, int32_t value, __unused BOOL *stop) {
4540      block([NSString stringWithFormat:@"%d", key], @(value));
4541  }];
4542}
4543
4544- (BOOL)getEnum:(int32_t *)value forKey:(int32_t)key {
4545  NSNumber *wrapped = [_dictionary objectForKey:@(key)];
4546  if (wrapped && value) {
4547    int32_t result = [wrapped intValue];
4548    if (!_validationFunc(result)) {
4549      result = kGPBUnrecognizedEnumeratorValue;
4550    }
4551    *value = result;
4552  }
4553  return (wrapped != NULL);
4554}
4555
4556- (BOOL)getRawValue:(int32_t *)rawValue forKey:(int32_t)key {
4557  NSNumber *wrapped = [_dictionary objectForKey:@(key)];
4558  if (wrapped && rawValue) {
4559    *rawValue = [wrapped intValue];
4560  }
4561  return (wrapped != NULL);
4562}
4563
4564- (void)enumerateKeysAndEnumsUsingBlock:
4565    (void (NS_NOESCAPE ^)(int32_t key, int32_t value, BOOL *stop))block {
4566  GPBEnumValidationFunc func = _validationFunc;
4567  BOOL stop = NO;
4568  NSEnumerator *keys = [_dictionary keyEnumerator];
4569  NSNumber *aKey;
4570  while ((aKey = [keys nextObject])) {
4571    NSNumber *aValue = _dictionary[aKey];
4572      int32_t unwrapped = [aValue intValue];
4573      if (!func(unwrapped)) {
4574        unwrapped = kGPBUnrecognizedEnumeratorValue;
4575      }
4576    block([aKey intValue], unwrapped, &stop);
4577    if (stop) {
4578      break;
4579    }
4580  }
4581}
4582
4583- (void)addRawEntriesFromDictionary:(GPBInt32EnumDictionary *)otherDictionary {
4584  if (otherDictionary) {
4585    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
4586    if (_autocreator) {
4587      GPBAutocreatedDictionaryModified(_autocreator, self);
4588    }
4589  }
4590}
4591
4592- (void)setRawValue:(int32_t)value forKey:(int32_t)key {
4593  [_dictionary setObject:@(value) forKey:@(key)];
4594  if (_autocreator) {
4595    GPBAutocreatedDictionaryModified(_autocreator, self);
4596  }
4597}
4598
4599- (void)removeEnumForKey:(int32_t)aKey {
4600  [_dictionary removeObjectForKey:@(aKey)];
4601}
4602
4603- (void)removeAll {
4604  [_dictionary removeAllObjects];
4605}
4606
4607- (void)setEnum:(int32_t)value forKey:(int32_t)key {
4608  if (!_validationFunc(value)) {
4609    [NSException raise:NSInvalidArgumentException
4610                format:@"GPBInt32EnumDictionary: Attempt to set an unknown enum value (%d)",
4611                       value];
4612  }
4613
4614  [_dictionary setObject:@(value) forKey:@(key)];
4615  if (_autocreator) {
4616    GPBAutocreatedDictionaryModified(_autocreator, self);
4617  }
4618}
4619
4620@end
4621
4622#pragma mark - Int32 -> Object
4623
4624@implementation GPBInt32ObjectDictionary {
4625 @package
4626  NSMutableDictionary *_dictionary;
4627}
4628
4629- (instancetype)init {
4630  return [self initWithObjects:NULL forKeys:NULL count:0];
4631}
4632
4633- (instancetype)initWithObjects:(const id [])objects
4634                        forKeys:(const int32_t [])keys
4635                          count:(NSUInteger)count {
4636  self = [super init];
4637  if (self) {
4638    _dictionary = [[NSMutableDictionary alloc] init];
4639    if (count && objects && keys) {
4640      for (NSUInteger i = 0; i < count; ++i) {
4641        if (!objects[i]) {
4642          [NSException raise:NSInvalidArgumentException
4643                      format:@"Attempting to add nil object to a Dictionary"];
4644        }
4645        [_dictionary setObject:objects[i] forKey:@(keys[i])];
4646      }
4647    }
4648  }
4649  return self;
4650}
4651
4652- (instancetype)initWithDictionary:(GPBInt32ObjectDictionary *)dictionary {
4653  self = [self initWithObjects:NULL forKeys:NULL count:0];
4654  if (self) {
4655    if (dictionary) {
4656      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
4657    }
4658  }
4659  return self;
4660}
4661
4662- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
4663  return [self initWithObjects:NULL forKeys:NULL count:0];
4664}
4665
4666- (void)dealloc {
4667  NSAssert(!_autocreator,
4668           @"%@: Autocreator must be cleared before release, autocreator: %@",
4669           [self class], _autocreator);
4670  [_dictionary release];
4671  [super dealloc];
4672}
4673
4674- (instancetype)copyWithZone:(NSZone *)zone {
4675  return [[GPBInt32ObjectDictionary allocWithZone:zone] initWithDictionary:self];
4676}
4677
4678- (BOOL)isEqual:(id)other {
4679  if (self == other) {
4680    return YES;
4681  }
4682  if (![other isKindOfClass:[GPBInt32ObjectDictionary class]]) {
4683    return NO;
4684  }
4685  GPBInt32ObjectDictionary *otherDictionary = other;
4686  return [_dictionary isEqual:otherDictionary->_dictionary];
4687}
4688
4689- (NSUInteger)hash {
4690  return _dictionary.count;
4691}
4692
4693- (NSString *)description {
4694  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
4695}
4696
4697- (NSUInteger)count {
4698  return _dictionary.count;
4699}
4700
4701- (void)enumerateKeysAndObjectsUsingBlock:
4702    (void (NS_NOESCAPE ^)(int32_t key, id object, BOOL *stop))block {
4703  BOOL stop = NO;
4704  NSDictionary *internal = _dictionary;
4705  NSEnumerator *keys = [internal keyEnumerator];
4706  NSNumber *aKey;
4707  while ((aKey = [keys nextObject])) {
4708    id aObject = internal[aKey];
4709    block([aKey intValue], aObject, &stop);
4710    if (stop) {
4711      break;
4712    }
4713  }
4714}
4715
4716- (BOOL)isInitialized {
4717  for (GPBMessage *msg in [_dictionary objectEnumerator]) {
4718    if (!msg.initialized) {
4719      return NO;
4720    }
4721  }
4722  return YES;
4723}
4724
4725- (instancetype)deepCopyWithZone:(NSZone *)zone {
4726  GPBInt32ObjectDictionary *newDict =
4727      [[GPBInt32ObjectDictionary alloc] init];
4728  NSEnumerator *keys = [_dictionary keyEnumerator];
4729  id aKey;
4730  NSMutableDictionary *internalDict = newDict->_dictionary;
4731  while ((aKey = [keys nextObject])) {
4732    GPBMessage *msg = _dictionary[aKey];
4733    GPBMessage *copiedMsg = [msg copyWithZone:zone];
4734    [internalDict setObject:copiedMsg forKey:aKey];
4735    [copiedMsg release];
4736  }
4737  return newDict;
4738}
4739
4740- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
4741  NSDictionary *internal = _dictionary;
4742  NSUInteger count = internal.count;
4743  if (count == 0) {
4744    return 0;
4745  }
4746
4747  GPBDataType valueDataType = GPBGetFieldDataType(field);
4748  GPBDataType keyDataType = field.mapKeyDataType;
4749  size_t result = 0;
4750  NSEnumerator *keys = [internal keyEnumerator];
4751  NSNumber *aKey;
4752  while ((aKey = [keys nextObject])) {
4753    id aObject = internal[aKey];
4754    size_t msgSize = ComputeDictInt32FieldSize([aKey intValue], kMapKeyFieldNumber, keyDataType);
4755    msgSize += ComputeDictObjectFieldSize(aObject, kMapValueFieldNumber, valueDataType);
4756    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
4757  }
4758  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
4759  result += tagSize * count;
4760  return result;
4761}
4762
4763- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
4764                         asField:(GPBFieldDescriptor *)field {
4765  GPBDataType valueDataType = GPBGetFieldDataType(field);
4766  GPBDataType keyDataType = field.mapKeyDataType;
4767  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
4768  NSDictionary *internal = _dictionary;
4769  NSEnumerator *keys = [internal keyEnumerator];
4770  NSNumber *aKey;
4771  while ((aKey = [keys nextObject])) {
4772    id aObject = internal[aKey];
4773    [outputStream writeInt32NoTag:tag];
4774    // Write the size of the message.
4775    int32_t unwrappedKey = [aKey intValue];
4776    id unwrappedValue = aObject;
4777    size_t msgSize = ComputeDictInt32FieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
4778    msgSize += ComputeDictObjectFieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
4779    [outputStream writeInt32NoTag:(int32_t)msgSize];
4780    // Write the fields.
4781    WriteDictInt32Field(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
4782    WriteDictObjectField(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
4783  }
4784}
4785
4786- (void)setGPBGenericValue:(GPBGenericValue *)value
4787     forGPBGenericValueKey:(GPBGenericValue *)key {
4788  [_dictionary setObject:value->valueString forKey:@(key->valueInt32)];
4789}
4790
4791- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
4792  [self enumerateKeysAndObjectsUsingBlock:^(int32_t key, id object, __unused BOOL *stop) {
4793      block([NSString stringWithFormat:@"%d", key], object);
4794  }];
4795}
4796
4797- (id)objectForKey:(int32_t)key {
4798  id result = [_dictionary objectForKey:@(key)];
4799  return result;
4800}
4801
4802- (void)addEntriesFromDictionary:(GPBInt32ObjectDictionary *)otherDictionary {
4803  if (otherDictionary) {
4804    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
4805    if (_autocreator) {
4806      GPBAutocreatedDictionaryModified(_autocreator, self);
4807    }
4808  }
4809}
4810
4811- (void)setObject:(id)object forKey:(int32_t)key {
4812  if (!object) {
4813    [NSException raise:NSInvalidArgumentException
4814                format:@"Attempting to add nil object to a Dictionary"];
4815  }
4816  [_dictionary setObject:object forKey:@(key)];
4817  if (_autocreator) {
4818    GPBAutocreatedDictionaryModified(_autocreator, self);
4819  }
4820}
4821
4822- (void)removeObjectForKey:(int32_t)aKey {
4823  [_dictionary removeObjectForKey:@(aKey)];
4824}
4825
4826- (void)removeAll {
4827  [_dictionary removeAllObjects];
4828}
4829
4830@end
4831
4832//%PDDM-EXPAND DICTIONARY_IMPL_FOR_POD_KEY(UInt64, uint64_t)
4833// This block of code is generated, do not edit it directly.
4834
4835#pragma mark - UInt64 -> UInt32
4836
4837@implementation GPBUInt64UInt32Dictionary {
4838 @package
4839  NSMutableDictionary *_dictionary;
4840}
4841
4842- (instancetype)init {
4843  return [self initWithUInt32s:NULL forKeys:NULL count:0];
4844}
4845
4846- (instancetype)initWithUInt32s:(const uint32_t [])values
4847                        forKeys:(const uint64_t [])keys
4848                          count:(NSUInteger)count {
4849  self = [super init];
4850  if (self) {
4851    _dictionary = [[NSMutableDictionary alloc] init];
4852    if (count && values && keys) {
4853      for (NSUInteger i = 0; i < count; ++i) {
4854        [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
4855      }
4856    }
4857  }
4858  return self;
4859}
4860
4861- (instancetype)initWithDictionary:(GPBUInt64UInt32Dictionary *)dictionary {
4862  self = [self initWithUInt32s:NULL forKeys:NULL count:0];
4863  if (self) {
4864    if (dictionary) {
4865      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
4866    }
4867  }
4868  return self;
4869}
4870
4871- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
4872  return [self initWithUInt32s:NULL forKeys:NULL count:0];
4873}
4874
4875- (void)dealloc {
4876  NSAssert(!_autocreator,
4877           @"%@: Autocreator must be cleared before release, autocreator: %@",
4878           [self class], _autocreator);
4879  [_dictionary release];
4880  [super dealloc];
4881}
4882
4883- (instancetype)copyWithZone:(NSZone *)zone {
4884  return [[GPBUInt64UInt32Dictionary allocWithZone:zone] initWithDictionary:self];
4885}
4886
4887- (BOOL)isEqual:(id)other {
4888  if (self == other) {
4889    return YES;
4890  }
4891  if (![other isKindOfClass:[GPBUInt64UInt32Dictionary class]]) {
4892    return NO;
4893  }
4894  GPBUInt64UInt32Dictionary *otherDictionary = other;
4895  return [_dictionary isEqual:otherDictionary->_dictionary];
4896}
4897
4898- (NSUInteger)hash {
4899  return _dictionary.count;
4900}
4901
4902- (NSString *)description {
4903  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
4904}
4905
4906- (NSUInteger)count {
4907  return _dictionary.count;
4908}
4909
4910- (void)enumerateKeysAndUInt32sUsingBlock:
4911    (void (NS_NOESCAPE ^)(uint64_t key, uint32_t value, BOOL *stop))block {
4912  BOOL stop = NO;
4913  NSDictionary *internal = _dictionary;
4914  NSEnumerator *keys = [internal keyEnumerator];
4915  NSNumber *aKey;
4916  while ((aKey = [keys nextObject])) {
4917    NSNumber *aValue = internal[aKey];
4918    block([aKey unsignedLongLongValue], [aValue unsignedIntValue], &stop);
4919    if (stop) {
4920      break;
4921    }
4922  }
4923}
4924
4925- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
4926  NSDictionary *internal = _dictionary;
4927  NSUInteger count = internal.count;
4928  if (count == 0) {
4929    return 0;
4930  }
4931
4932  GPBDataType valueDataType = GPBGetFieldDataType(field);
4933  GPBDataType keyDataType = field.mapKeyDataType;
4934  size_t result = 0;
4935  NSEnumerator *keys = [internal keyEnumerator];
4936  NSNumber *aKey;
4937  while ((aKey = [keys nextObject])) {
4938    NSNumber *aValue = internal[aKey];
4939    size_t msgSize = ComputeDictUInt64FieldSize([aKey unsignedLongLongValue], kMapKeyFieldNumber, keyDataType);
4940    msgSize += ComputeDictUInt32FieldSize([aValue unsignedIntValue], kMapValueFieldNumber, valueDataType);
4941    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
4942  }
4943  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
4944  result += tagSize * count;
4945  return result;
4946}
4947
4948- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
4949                         asField:(GPBFieldDescriptor *)field {
4950  GPBDataType valueDataType = GPBGetFieldDataType(field);
4951  GPBDataType keyDataType = field.mapKeyDataType;
4952  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
4953  NSDictionary *internal = _dictionary;
4954  NSEnumerator *keys = [internal keyEnumerator];
4955  NSNumber *aKey;
4956  while ((aKey = [keys nextObject])) {
4957    NSNumber *aValue = internal[aKey];
4958    [outputStream writeInt32NoTag:tag];
4959    // Write the size of the message.
4960    uint64_t unwrappedKey = [aKey unsignedLongLongValue];
4961    uint32_t unwrappedValue = [aValue unsignedIntValue];
4962    size_t msgSize = ComputeDictUInt64FieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
4963    msgSize += ComputeDictUInt32FieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
4964    [outputStream writeInt32NoTag:(int32_t)msgSize];
4965    // Write the fields.
4966    WriteDictUInt64Field(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
4967    WriteDictUInt32Field(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
4968  }
4969}
4970
4971- (void)setGPBGenericValue:(GPBGenericValue *)value
4972     forGPBGenericValueKey:(GPBGenericValue *)key {
4973  [_dictionary setObject:@(value->valueUInt32) forKey:@(key->valueUInt64)];
4974}
4975
4976- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
4977  [self enumerateKeysAndUInt32sUsingBlock:^(uint64_t key, uint32_t value, __unused BOOL *stop) {
4978      block([NSString stringWithFormat:@"%llu", key], [NSString stringWithFormat:@"%u", value]);
4979  }];
4980}
4981
4982- (BOOL)getUInt32:(nullable uint32_t *)value forKey:(uint64_t)key {
4983  NSNumber *wrapped = [_dictionary objectForKey:@(key)];
4984  if (wrapped && value) {
4985    *value = [wrapped unsignedIntValue];
4986  }
4987  return (wrapped != NULL);
4988}
4989
4990- (void)addEntriesFromDictionary:(GPBUInt64UInt32Dictionary *)otherDictionary {
4991  if (otherDictionary) {
4992    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
4993    if (_autocreator) {
4994      GPBAutocreatedDictionaryModified(_autocreator, self);
4995    }
4996  }
4997}
4998
4999- (void)setUInt32:(uint32_t)value forKey:(uint64_t)key {
5000  [_dictionary setObject:@(value) forKey:@(key)];
5001  if (_autocreator) {
5002    GPBAutocreatedDictionaryModified(_autocreator, self);
5003  }
5004}
5005
5006- (void)removeUInt32ForKey:(uint64_t)aKey {
5007  [_dictionary removeObjectForKey:@(aKey)];
5008}
5009
5010- (void)removeAll {
5011  [_dictionary removeAllObjects];
5012}
5013
5014@end
5015
5016#pragma mark - UInt64 -> Int32
5017
5018@implementation GPBUInt64Int32Dictionary {
5019 @package
5020  NSMutableDictionary *_dictionary;
5021}
5022
5023- (instancetype)init {
5024  return [self initWithInt32s:NULL forKeys:NULL count:0];
5025}
5026
5027- (instancetype)initWithInt32s:(const int32_t [])values
5028                       forKeys:(const uint64_t [])keys
5029                         count:(NSUInteger)count {
5030  self = [super init];
5031  if (self) {
5032    _dictionary = [[NSMutableDictionary alloc] init];
5033    if (count && values && keys) {
5034      for (NSUInteger i = 0; i < count; ++i) {
5035        [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
5036      }
5037    }
5038  }
5039  return self;
5040}
5041
5042- (instancetype)initWithDictionary:(GPBUInt64Int32Dictionary *)dictionary {
5043  self = [self initWithInt32s:NULL forKeys:NULL count:0];
5044  if (self) {
5045    if (dictionary) {
5046      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
5047    }
5048  }
5049  return self;
5050}
5051
5052- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
5053  return [self initWithInt32s:NULL forKeys:NULL count:0];
5054}
5055
5056- (void)dealloc {
5057  NSAssert(!_autocreator,
5058           @"%@: Autocreator must be cleared before release, autocreator: %@",
5059           [self class], _autocreator);
5060  [_dictionary release];
5061  [super dealloc];
5062}
5063
5064- (instancetype)copyWithZone:(NSZone *)zone {
5065  return [[GPBUInt64Int32Dictionary allocWithZone:zone] initWithDictionary:self];
5066}
5067
5068- (BOOL)isEqual:(id)other {
5069  if (self == other) {
5070    return YES;
5071  }
5072  if (![other isKindOfClass:[GPBUInt64Int32Dictionary class]]) {
5073    return NO;
5074  }
5075  GPBUInt64Int32Dictionary *otherDictionary = other;
5076  return [_dictionary isEqual:otherDictionary->_dictionary];
5077}
5078
5079- (NSUInteger)hash {
5080  return _dictionary.count;
5081}
5082
5083- (NSString *)description {
5084  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
5085}
5086
5087- (NSUInteger)count {
5088  return _dictionary.count;
5089}
5090
5091- (void)enumerateKeysAndInt32sUsingBlock:
5092    (void (NS_NOESCAPE ^)(uint64_t key, int32_t value, BOOL *stop))block {
5093  BOOL stop = NO;
5094  NSDictionary *internal = _dictionary;
5095  NSEnumerator *keys = [internal keyEnumerator];
5096  NSNumber *aKey;
5097  while ((aKey = [keys nextObject])) {
5098    NSNumber *aValue = internal[aKey];
5099    block([aKey unsignedLongLongValue], [aValue intValue], &stop);
5100    if (stop) {
5101      break;
5102    }
5103  }
5104}
5105
5106- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
5107  NSDictionary *internal = _dictionary;
5108  NSUInteger count = internal.count;
5109  if (count == 0) {
5110    return 0;
5111  }
5112
5113  GPBDataType valueDataType = GPBGetFieldDataType(field);
5114  GPBDataType keyDataType = field.mapKeyDataType;
5115  size_t result = 0;
5116  NSEnumerator *keys = [internal keyEnumerator];
5117  NSNumber *aKey;
5118  while ((aKey = [keys nextObject])) {
5119    NSNumber *aValue = internal[aKey];
5120    size_t msgSize = ComputeDictUInt64FieldSize([aKey unsignedLongLongValue], kMapKeyFieldNumber, keyDataType);
5121    msgSize += ComputeDictInt32FieldSize([aValue intValue], kMapValueFieldNumber, valueDataType);
5122    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
5123  }
5124  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
5125  result += tagSize * count;
5126  return result;
5127}
5128
5129- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
5130                         asField:(GPBFieldDescriptor *)field {
5131  GPBDataType valueDataType = GPBGetFieldDataType(field);
5132  GPBDataType keyDataType = field.mapKeyDataType;
5133  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
5134  NSDictionary *internal = _dictionary;
5135  NSEnumerator *keys = [internal keyEnumerator];
5136  NSNumber *aKey;
5137  while ((aKey = [keys nextObject])) {
5138    NSNumber *aValue = internal[aKey];
5139    [outputStream writeInt32NoTag:tag];
5140    // Write the size of the message.
5141    uint64_t unwrappedKey = [aKey unsignedLongLongValue];
5142    int32_t unwrappedValue = [aValue intValue];
5143    size_t msgSize = ComputeDictUInt64FieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
5144    msgSize += ComputeDictInt32FieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
5145    [outputStream writeInt32NoTag:(int32_t)msgSize];
5146    // Write the fields.
5147    WriteDictUInt64Field(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
5148    WriteDictInt32Field(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
5149  }
5150}
5151
5152- (void)setGPBGenericValue:(GPBGenericValue *)value
5153     forGPBGenericValueKey:(GPBGenericValue *)key {
5154  [_dictionary setObject:@(value->valueInt32) forKey:@(key->valueUInt64)];
5155}
5156
5157- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
5158  [self enumerateKeysAndInt32sUsingBlock:^(uint64_t key, int32_t value, __unused BOOL *stop) {
5159      block([NSString stringWithFormat:@"%llu", key], [NSString stringWithFormat:@"%d", value]);
5160  }];
5161}
5162
5163- (BOOL)getInt32:(nullable int32_t *)value forKey:(uint64_t)key {
5164  NSNumber *wrapped = [_dictionary objectForKey:@(key)];
5165  if (wrapped && value) {
5166    *value = [wrapped intValue];
5167  }
5168  return (wrapped != NULL);
5169}
5170
5171- (void)addEntriesFromDictionary:(GPBUInt64Int32Dictionary *)otherDictionary {
5172  if (otherDictionary) {
5173    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
5174    if (_autocreator) {
5175      GPBAutocreatedDictionaryModified(_autocreator, self);
5176    }
5177  }
5178}
5179
5180- (void)setInt32:(int32_t)value forKey:(uint64_t)key {
5181  [_dictionary setObject:@(value) forKey:@(key)];
5182  if (_autocreator) {
5183    GPBAutocreatedDictionaryModified(_autocreator, self);
5184  }
5185}
5186
5187- (void)removeInt32ForKey:(uint64_t)aKey {
5188  [_dictionary removeObjectForKey:@(aKey)];
5189}
5190
5191- (void)removeAll {
5192  [_dictionary removeAllObjects];
5193}
5194
5195@end
5196
5197#pragma mark - UInt64 -> UInt64
5198
5199@implementation GPBUInt64UInt64Dictionary {
5200 @package
5201  NSMutableDictionary *_dictionary;
5202}
5203
5204- (instancetype)init {
5205  return [self initWithUInt64s:NULL forKeys:NULL count:0];
5206}
5207
5208- (instancetype)initWithUInt64s:(const uint64_t [])values
5209                        forKeys:(const uint64_t [])keys
5210                          count:(NSUInteger)count {
5211  self = [super init];
5212  if (self) {
5213    _dictionary = [[NSMutableDictionary alloc] init];
5214    if (count && values && keys) {
5215      for (NSUInteger i = 0; i < count; ++i) {
5216        [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
5217      }
5218    }
5219  }
5220  return self;
5221}
5222
5223- (instancetype)initWithDictionary:(GPBUInt64UInt64Dictionary *)dictionary {
5224  self = [self initWithUInt64s:NULL forKeys:NULL count:0];
5225  if (self) {
5226    if (dictionary) {
5227      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
5228    }
5229  }
5230  return self;
5231}
5232
5233- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
5234  return [self initWithUInt64s:NULL forKeys:NULL count:0];
5235}
5236
5237- (void)dealloc {
5238  NSAssert(!_autocreator,
5239           @"%@: Autocreator must be cleared before release, autocreator: %@",
5240           [self class], _autocreator);
5241  [_dictionary release];
5242  [super dealloc];
5243}
5244
5245- (instancetype)copyWithZone:(NSZone *)zone {
5246  return [[GPBUInt64UInt64Dictionary allocWithZone:zone] initWithDictionary:self];
5247}
5248
5249- (BOOL)isEqual:(id)other {
5250  if (self == other) {
5251    return YES;
5252  }
5253  if (![other isKindOfClass:[GPBUInt64UInt64Dictionary class]]) {
5254    return NO;
5255  }
5256  GPBUInt64UInt64Dictionary *otherDictionary = other;
5257  return [_dictionary isEqual:otherDictionary->_dictionary];
5258}
5259
5260- (NSUInteger)hash {
5261  return _dictionary.count;
5262}
5263
5264- (NSString *)description {
5265  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
5266}
5267
5268- (NSUInteger)count {
5269  return _dictionary.count;
5270}
5271
5272- (void)enumerateKeysAndUInt64sUsingBlock:
5273    (void (NS_NOESCAPE ^)(uint64_t key, uint64_t value, BOOL *stop))block {
5274  BOOL stop = NO;
5275  NSDictionary *internal = _dictionary;
5276  NSEnumerator *keys = [internal keyEnumerator];
5277  NSNumber *aKey;
5278  while ((aKey = [keys nextObject])) {
5279    NSNumber *aValue = internal[aKey];
5280    block([aKey unsignedLongLongValue], [aValue unsignedLongLongValue], &stop);
5281    if (stop) {
5282      break;
5283    }
5284  }
5285}
5286
5287- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
5288  NSDictionary *internal = _dictionary;
5289  NSUInteger count = internal.count;
5290  if (count == 0) {
5291    return 0;
5292  }
5293
5294  GPBDataType valueDataType = GPBGetFieldDataType(field);
5295  GPBDataType keyDataType = field.mapKeyDataType;
5296  size_t result = 0;
5297  NSEnumerator *keys = [internal keyEnumerator];
5298  NSNumber *aKey;
5299  while ((aKey = [keys nextObject])) {
5300    NSNumber *aValue = internal[aKey];
5301    size_t msgSize = ComputeDictUInt64FieldSize([aKey unsignedLongLongValue], kMapKeyFieldNumber, keyDataType);
5302    msgSize += ComputeDictUInt64FieldSize([aValue unsignedLongLongValue], kMapValueFieldNumber, valueDataType);
5303    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
5304  }
5305  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
5306  result += tagSize * count;
5307  return result;
5308}
5309
5310- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
5311                         asField:(GPBFieldDescriptor *)field {
5312  GPBDataType valueDataType = GPBGetFieldDataType(field);
5313  GPBDataType keyDataType = field.mapKeyDataType;
5314  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
5315  NSDictionary *internal = _dictionary;
5316  NSEnumerator *keys = [internal keyEnumerator];
5317  NSNumber *aKey;
5318  while ((aKey = [keys nextObject])) {
5319    NSNumber *aValue = internal[aKey];
5320    [outputStream writeInt32NoTag:tag];
5321    // Write the size of the message.
5322    uint64_t unwrappedKey = [aKey unsignedLongLongValue];
5323    uint64_t unwrappedValue = [aValue unsignedLongLongValue];
5324    size_t msgSize = ComputeDictUInt64FieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
5325    msgSize += ComputeDictUInt64FieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
5326    [outputStream writeInt32NoTag:(int32_t)msgSize];
5327    // Write the fields.
5328    WriteDictUInt64Field(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
5329    WriteDictUInt64Field(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
5330  }
5331}
5332
5333- (void)setGPBGenericValue:(GPBGenericValue *)value
5334     forGPBGenericValueKey:(GPBGenericValue *)key {
5335  [_dictionary setObject:@(value->valueUInt64) forKey:@(key->valueUInt64)];
5336}
5337
5338- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
5339  [self enumerateKeysAndUInt64sUsingBlock:^(uint64_t key, uint64_t value, __unused BOOL *stop) {
5340      block([NSString stringWithFormat:@"%llu", key], [NSString stringWithFormat:@"%llu", value]);
5341  }];
5342}
5343
5344- (BOOL)getUInt64:(nullable uint64_t *)value forKey:(uint64_t)key {
5345  NSNumber *wrapped = [_dictionary objectForKey:@(key)];
5346  if (wrapped && value) {
5347    *value = [wrapped unsignedLongLongValue];
5348  }
5349  return (wrapped != NULL);
5350}
5351
5352- (void)addEntriesFromDictionary:(GPBUInt64UInt64Dictionary *)otherDictionary {
5353  if (otherDictionary) {
5354    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
5355    if (_autocreator) {
5356      GPBAutocreatedDictionaryModified(_autocreator, self);
5357    }
5358  }
5359}
5360
5361- (void)setUInt64:(uint64_t)value forKey:(uint64_t)key {
5362  [_dictionary setObject:@(value) forKey:@(key)];
5363  if (_autocreator) {
5364    GPBAutocreatedDictionaryModified(_autocreator, self);
5365  }
5366}
5367
5368- (void)removeUInt64ForKey:(uint64_t)aKey {
5369  [_dictionary removeObjectForKey:@(aKey)];
5370}
5371
5372- (void)removeAll {
5373  [_dictionary removeAllObjects];
5374}
5375
5376@end
5377
5378#pragma mark - UInt64 -> Int64
5379
5380@implementation GPBUInt64Int64Dictionary {
5381 @package
5382  NSMutableDictionary *_dictionary;
5383}
5384
5385- (instancetype)init {
5386  return [self initWithInt64s:NULL forKeys:NULL count:0];
5387}
5388
5389- (instancetype)initWithInt64s:(const int64_t [])values
5390                       forKeys:(const uint64_t [])keys
5391                         count:(NSUInteger)count {
5392  self = [super init];
5393  if (self) {
5394    _dictionary = [[NSMutableDictionary alloc] init];
5395    if (count && values && keys) {
5396      for (NSUInteger i = 0; i < count; ++i) {
5397        [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
5398      }
5399    }
5400  }
5401  return self;
5402}
5403
5404- (instancetype)initWithDictionary:(GPBUInt64Int64Dictionary *)dictionary {
5405  self = [self initWithInt64s:NULL forKeys:NULL count:0];
5406  if (self) {
5407    if (dictionary) {
5408      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
5409    }
5410  }
5411  return self;
5412}
5413
5414- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
5415  return [self initWithInt64s:NULL forKeys:NULL count:0];
5416}
5417
5418- (void)dealloc {
5419  NSAssert(!_autocreator,
5420           @"%@: Autocreator must be cleared before release, autocreator: %@",
5421           [self class], _autocreator);
5422  [_dictionary release];
5423  [super dealloc];
5424}
5425
5426- (instancetype)copyWithZone:(NSZone *)zone {
5427  return [[GPBUInt64Int64Dictionary allocWithZone:zone] initWithDictionary:self];
5428}
5429
5430- (BOOL)isEqual:(id)other {
5431  if (self == other) {
5432    return YES;
5433  }
5434  if (![other isKindOfClass:[GPBUInt64Int64Dictionary class]]) {
5435    return NO;
5436  }
5437  GPBUInt64Int64Dictionary *otherDictionary = other;
5438  return [_dictionary isEqual:otherDictionary->_dictionary];
5439}
5440
5441- (NSUInteger)hash {
5442  return _dictionary.count;
5443}
5444
5445- (NSString *)description {
5446  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
5447}
5448
5449- (NSUInteger)count {
5450  return _dictionary.count;
5451}
5452
5453- (void)enumerateKeysAndInt64sUsingBlock:
5454    (void (NS_NOESCAPE ^)(uint64_t key, int64_t value, BOOL *stop))block {
5455  BOOL stop = NO;
5456  NSDictionary *internal = _dictionary;
5457  NSEnumerator *keys = [internal keyEnumerator];
5458  NSNumber *aKey;
5459  while ((aKey = [keys nextObject])) {
5460    NSNumber *aValue = internal[aKey];
5461    block([aKey unsignedLongLongValue], [aValue longLongValue], &stop);
5462    if (stop) {
5463      break;
5464    }
5465  }
5466}
5467
5468- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
5469  NSDictionary *internal = _dictionary;
5470  NSUInteger count = internal.count;
5471  if (count == 0) {
5472    return 0;
5473  }
5474
5475  GPBDataType valueDataType = GPBGetFieldDataType(field);
5476  GPBDataType keyDataType = field.mapKeyDataType;
5477  size_t result = 0;
5478  NSEnumerator *keys = [internal keyEnumerator];
5479  NSNumber *aKey;
5480  while ((aKey = [keys nextObject])) {
5481    NSNumber *aValue = internal[aKey];
5482    size_t msgSize = ComputeDictUInt64FieldSize([aKey unsignedLongLongValue], kMapKeyFieldNumber, keyDataType);
5483    msgSize += ComputeDictInt64FieldSize([aValue longLongValue], kMapValueFieldNumber, valueDataType);
5484    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
5485  }
5486  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
5487  result += tagSize * count;
5488  return result;
5489}
5490
5491- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
5492                         asField:(GPBFieldDescriptor *)field {
5493  GPBDataType valueDataType = GPBGetFieldDataType(field);
5494  GPBDataType keyDataType = field.mapKeyDataType;
5495  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
5496  NSDictionary *internal = _dictionary;
5497  NSEnumerator *keys = [internal keyEnumerator];
5498  NSNumber *aKey;
5499  while ((aKey = [keys nextObject])) {
5500    NSNumber *aValue = internal[aKey];
5501    [outputStream writeInt32NoTag:tag];
5502    // Write the size of the message.
5503    uint64_t unwrappedKey = [aKey unsignedLongLongValue];
5504    int64_t unwrappedValue = [aValue longLongValue];
5505    size_t msgSize = ComputeDictUInt64FieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
5506    msgSize += ComputeDictInt64FieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
5507    [outputStream writeInt32NoTag:(int32_t)msgSize];
5508    // Write the fields.
5509    WriteDictUInt64Field(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
5510    WriteDictInt64Field(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
5511  }
5512}
5513
5514- (void)setGPBGenericValue:(GPBGenericValue *)value
5515     forGPBGenericValueKey:(GPBGenericValue *)key {
5516  [_dictionary setObject:@(value->valueInt64) forKey:@(key->valueUInt64)];
5517}
5518
5519- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
5520  [self enumerateKeysAndInt64sUsingBlock:^(uint64_t key, int64_t value, __unused BOOL *stop) {
5521      block([NSString stringWithFormat:@"%llu", key], [NSString stringWithFormat:@"%lld", value]);
5522  }];
5523}
5524
5525- (BOOL)getInt64:(nullable int64_t *)value forKey:(uint64_t)key {
5526  NSNumber *wrapped = [_dictionary objectForKey:@(key)];
5527  if (wrapped && value) {
5528    *value = [wrapped longLongValue];
5529  }
5530  return (wrapped != NULL);
5531}
5532
5533- (void)addEntriesFromDictionary:(GPBUInt64Int64Dictionary *)otherDictionary {
5534  if (otherDictionary) {
5535    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
5536    if (_autocreator) {
5537      GPBAutocreatedDictionaryModified(_autocreator, self);
5538    }
5539  }
5540}
5541
5542- (void)setInt64:(int64_t)value forKey:(uint64_t)key {
5543  [_dictionary setObject:@(value) forKey:@(key)];
5544  if (_autocreator) {
5545    GPBAutocreatedDictionaryModified(_autocreator, self);
5546  }
5547}
5548
5549- (void)removeInt64ForKey:(uint64_t)aKey {
5550  [_dictionary removeObjectForKey:@(aKey)];
5551}
5552
5553- (void)removeAll {
5554  [_dictionary removeAllObjects];
5555}
5556
5557@end
5558
5559#pragma mark - UInt64 -> Bool
5560
5561@implementation GPBUInt64BoolDictionary {
5562 @package
5563  NSMutableDictionary *_dictionary;
5564}
5565
5566- (instancetype)init {
5567  return [self initWithBools:NULL forKeys:NULL count:0];
5568}
5569
5570- (instancetype)initWithBools:(const BOOL [])values
5571                      forKeys:(const uint64_t [])keys
5572                        count:(NSUInteger)count {
5573  self = [super init];
5574  if (self) {
5575    _dictionary = [[NSMutableDictionary alloc] init];
5576    if (count && values && keys) {
5577      for (NSUInteger i = 0; i < count; ++i) {
5578        [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
5579      }
5580    }
5581  }
5582  return self;
5583}
5584
5585- (instancetype)initWithDictionary:(GPBUInt64BoolDictionary *)dictionary {
5586  self = [self initWithBools:NULL forKeys:NULL count:0];
5587  if (self) {
5588    if (dictionary) {
5589      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
5590    }
5591  }
5592  return self;
5593}
5594
5595- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
5596  return [self initWithBools:NULL forKeys:NULL count:0];
5597}
5598
5599- (void)dealloc {
5600  NSAssert(!_autocreator,
5601           @"%@: Autocreator must be cleared before release, autocreator: %@",
5602           [self class], _autocreator);
5603  [_dictionary release];
5604  [super dealloc];
5605}
5606
5607- (instancetype)copyWithZone:(NSZone *)zone {
5608  return [[GPBUInt64BoolDictionary allocWithZone:zone] initWithDictionary:self];
5609}
5610
5611- (BOOL)isEqual:(id)other {
5612  if (self == other) {
5613    return YES;
5614  }
5615  if (![other isKindOfClass:[GPBUInt64BoolDictionary class]]) {
5616    return NO;
5617  }
5618  GPBUInt64BoolDictionary *otherDictionary = other;
5619  return [_dictionary isEqual:otherDictionary->_dictionary];
5620}
5621
5622- (NSUInteger)hash {
5623  return _dictionary.count;
5624}
5625
5626- (NSString *)description {
5627  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
5628}
5629
5630- (NSUInteger)count {
5631  return _dictionary.count;
5632}
5633
5634- (void)enumerateKeysAndBoolsUsingBlock:
5635    (void (NS_NOESCAPE ^)(uint64_t key, BOOL value, BOOL *stop))block {
5636  BOOL stop = NO;
5637  NSDictionary *internal = _dictionary;
5638  NSEnumerator *keys = [internal keyEnumerator];
5639  NSNumber *aKey;
5640  while ((aKey = [keys nextObject])) {
5641    NSNumber *aValue = internal[aKey];
5642    block([aKey unsignedLongLongValue], [aValue boolValue], &stop);
5643    if (stop) {
5644      break;
5645    }
5646  }
5647}
5648
5649- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
5650  NSDictionary *internal = _dictionary;
5651  NSUInteger count = internal.count;
5652  if (count == 0) {
5653    return 0;
5654  }
5655
5656  GPBDataType valueDataType = GPBGetFieldDataType(field);
5657  GPBDataType keyDataType = field.mapKeyDataType;
5658  size_t result = 0;
5659  NSEnumerator *keys = [internal keyEnumerator];
5660  NSNumber *aKey;
5661  while ((aKey = [keys nextObject])) {
5662    NSNumber *aValue = internal[aKey];
5663    size_t msgSize = ComputeDictUInt64FieldSize([aKey unsignedLongLongValue], kMapKeyFieldNumber, keyDataType);
5664    msgSize += ComputeDictBoolFieldSize([aValue boolValue], kMapValueFieldNumber, valueDataType);
5665    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
5666  }
5667  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
5668  result += tagSize * count;
5669  return result;
5670}
5671
5672- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
5673                         asField:(GPBFieldDescriptor *)field {
5674  GPBDataType valueDataType = GPBGetFieldDataType(field);
5675  GPBDataType keyDataType = field.mapKeyDataType;
5676  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
5677  NSDictionary *internal = _dictionary;
5678  NSEnumerator *keys = [internal keyEnumerator];
5679  NSNumber *aKey;
5680  while ((aKey = [keys nextObject])) {
5681    NSNumber *aValue = internal[aKey];
5682    [outputStream writeInt32NoTag:tag];
5683    // Write the size of the message.
5684    uint64_t unwrappedKey = [aKey unsignedLongLongValue];
5685    BOOL unwrappedValue = [aValue boolValue];
5686    size_t msgSize = ComputeDictUInt64FieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
5687    msgSize += ComputeDictBoolFieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
5688    [outputStream writeInt32NoTag:(int32_t)msgSize];
5689    // Write the fields.
5690    WriteDictUInt64Field(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
5691    WriteDictBoolField(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
5692  }
5693}
5694
5695- (void)setGPBGenericValue:(GPBGenericValue *)value
5696     forGPBGenericValueKey:(GPBGenericValue *)key {
5697  [_dictionary setObject:@(value->valueBool) forKey:@(key->valueUInt64)];
5698}
5699
5700- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
5701  [self enumerateKeysAndBoolsUsingBlock:^(uint64_t key, BOOL value, __unused BOOL *stop) {
5702      block([NSString stringWithFormat:@"%llu", key], (value ? @"true" : @"false"));
5703  }];
5704}
5705
5706- (BOOL)getBool:(nullable BOOL *)value forKey:(uint64_t)key {
5707  NSNumber *wrapped = [_dictionary objectForKey:@(key)];
5708  if (wrapped && value) {
5709    *value = [wrapped boolValue];
5710  }
5711  return (wrapped != NULL);
5712}
5713
5714- (void)addEntriesFromDictionary:(GPBUInt64BoolDictionary *)otherDictionary {
5715  if (otherDictionary) {
5716    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
5717    if (_autocreator) {
5718      GPBAutocreatedDictionaryModified(_autocreator, self);
5719    }
5720  }
5721}
5722
5723- (void)setBool:(BOOL)value forKey:(uint64_t)key {
5724  [_dictionary setObject:@(value) forKey:@(key)];
5725  if (_autocreator) {
5726    GPBAutocreatedDictionaryModified(_autocreator, self);
5727  }
5728}
5729
5730- (void)removeBoolForKey:(uint64_t)aKey {
5731  [_dictionary removeObjectForKey:@(aKey)];
5732}
5733
5734- (void)removeAll {
5735  [_dictionary removeAllObjects];
5736}
5737
5738@end
5739
5740#pragma mark - UInt64 -> Float
5741
5742@implementation GPBUInt64FloatDictionary {
5743 @package
5744  NSMutableDictionary *_dictionary;
5745}
5746
5747- (instancetype)init {
5748  return [self initWithFloats:NULL forKeys:NULL count:0];
5749}
5750
5751- (instancetype)initWithFloats:(const float [])values
5752                       forKeys:(const uint64_t [])keys
5753                         count:(NSUInteger)count {
5754  self = [super init];
5755  if (self) {
5756    _dictionary = [[NSMutableDictionary alloc] init];
5757    if (count && values && keys) {
5758      for (NSUInteger i = 0; i < count; ++i) {
5759        [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
5760      }
5761    }
5762  }
5763  return self;
5764}
5765
5766- (instancetype)initWithDictionary:(GPBUInt64FloatDictionary *)dictionary {
5767  self = [self initWithFloats:NULL forKeys:NULL count:0];
5768  if (self) {
5769    if (dictionary) {
5770      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
5771    }
5772  }
5773  return self;
5774}
5775
5776- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
5777  return [self initWithFloats:NULL forKeys:NULL count:0];
5778}
5779
5780- (void)dealloc {
5781  NSAssert(!_autocreator,
5782           @"%@: Autocreator must be cleared before release, autocreator: %@",
5783           [self class], _autocreator);
5784  [_dictionary release];
5785  [super dealloc];
5786}
5787
5788- (instancetype)copyWithZone:(NSZone *)zone {
5789  return [[GPBUInt64FloatDictionary allocWithZone:zone] initWithDictionary:self];
5790}
5791
5792- (BOOL)isEqual:(id)other {
5793  if (self == other) {
5794    return YES;
5795  }
5796  if (![other isKindOfClass:[GPBUInt64FloatDictionary class]]) {
5797    return NO;
5798  }
5799  GPBUInt64FloatDictionary *otherDictionary = other;
5800  return [_dictionary isEqual:otherDictionary->_dictionary];
5801}
5802
5803- (NSUInteger)hash {
5804  return _dictionary.count;
5805}
5806
5807- (NSString *)description {
5808  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
5809}
5810
5811- (NSUInteger)count {
5812  return _dictionary.count;
5813}
5814
5815- (void)enumerateKeysAndFloatsUsingBlock:
5816    (void (NS_NOESCAPE ^)(uint64_t key, float value, BOOL *stop))block {
5817  BOOL stop = NO;
5818  NSDictionary *internal = _dictionary;
5819  NSEnumerator *keys = [internal keyEnumerator];
5820  NSNumber *aKey;
5821  while ((aKey = [keys nextObject])) {
5822    NSNumber *aValue = internal[aKey];
5823    block([aKey unsignedLongLongValue], [aValue floatValue], &stop);
5824    if (stop) {
5825      break;
5826    }
5827  }
5828}
5829
5830- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
5831  NSDictionary *internal = _dictionary;
5832  NSUInteger count = internal.count;
5833  if (count == 0) {
5834    return 0;
5835  }
5836
5837  GPBDataType valueDataType = GPBGetFieldDataType(field);
5838  GPBDataType keyDataType = field.mapKeyDataType;
5839  size_t result = 0;
5840  NSEnumerator *keys = [internal keyEnumerator];
5841  NSNumber *aKey;
5842  while ((aKey = [keys nextObject])) {
5843    NSNumber *aValue = internal[aKey];
5844    size_t msgSize = ComputeDictUInt64FieldSize([aKey unsignedLongLongValue], kMapKeyFieldNumber, keyDataType);
5845    msgSize += ComputeDictFloatFieldSize([aValue floatValue], kMapValueFieldNumber, valueDataType);
5846    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
5847  }
5848  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
5849  result += tagSize * count;
5850  return result;
5851}
5852
5853- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
5854                         asField:(GPBFieldDescriptor *)field {
5855  GPBDataType valueDataType = GPBGetFieldDataType(field);
5856  GPBDataType keyDataType = field.mapKeyDataType;
5857  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
5858  NSDictionary *internal = _dictionary;
5859  NSEnumerator *keys = [internal keyEnumerator];
5860  NSNumber *aKey;
5861  while ((aKey = [keys nextObject])) {
5862    NSNumber *aValue = internal[aKey];
5863    [outputStream writeInt32NoTag:tag];
5864    // Write the size of the message.
5865    uint64_t unwrappedKey = [aKey unsignedLongLongValue];
5866    float unwrappedValue = [aValue floatValue];
5867    size_t msgSize = ComputeDictUInt64FieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
5868    msgSize += ComputeDictFloatFieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
5869    [outputStream writeInt32NoTag:(int32_t)msgSize];
5870    // Write the fields.
5871    WriteDictUInt64Field(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
5872    WriteDictFloatField(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
5873  }
5874}
5875
5876- (void)setGPBGenericValue:(GPBGenericValue *)value
5877     forGPBGenericValueKey:(GPBGenericValue *)key {
5878  [_dictionary setObject:@(value->valueFloat) forKey:@(key->valueUInt64)];
5879}
5880
5881- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
5882  [self enumerateKeysAndFloatsUsingBlock:^(uint64_t key, float value, __unused BOOL *stop) {
5883      block([NSString stringWithFormat:@"%llu", key], [NSString stringWithFormat:@"%.*g", FLT_DIG, value]);
5884  }];
5885}
5886
5887- (BOOL)getFloat:(nullable float *)value forKey:(uint64_t)key {
5888  NSNumber *wrapped = [_dictionary objectForKey:@(key)];
5889  if (wrapped && value) {
5890    *value = [wrapped floatValue];
5891  }
5892  return (wrapped != NULL);
5893}
5894
5895- (void)addEntriesFromDictionary:(GPBUInt64FloatDictionary *)otherDictionary {
5896  if (otherDictionary) {
5897    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
5898    if (_autocreator) {
5899      GPBAutocreatedDictionaryModified(_autocreator, self);
5900    }
5901  }
5902}
5903
5904- (void)setFloat:(float)value forKey:(uint64_t)key {
5905  [_dictionary setObject:@(value) forKey:@(key)];
5906  if (_autocreator) {
5907    GPBAutocreatedDictionaryModified(_autocreator, self);
5908  }
5909}
5910
5911- (void)removeFloatForKey:(uint64_t)aKey {
5912  [_dictionary removeObjectForKey:@(aKey)];
5913}
5914
5915- (void)removeAll {
5916  [_dictionary removeAllObjects];
5917}
5918
5919@end
5920
5921#pragma mark - UInt64 -> Double
5922
5923@implementation GPBUInt64DoubleDictionary {
5924 @package
5925  NSMutableDictionary *_dictionary;
5926}
5927
5928- (instancetype)init {
5929  return [self initWithDoubles:NULL forKeys:NULL count:0];
5930}
5931
5932- (instancetype)initWithDoubles:(const double [])values
5933                        forKeys:(const uint64_t [])keys
5934                          count:(NSUInteger)count {
5935  self = [super init];
5936  if (self) {
5937    _dictionary = [[NSMutableDictionary alloc] init];
5938    if (count && values && keys) {
5939      for (NSUInteger i = 0; i < count; ++i) {
5940        [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
5941      }
5942    }
5943  }
5944  return self;
5945}
5946
5947- (instancetype)initWithDictionary:(GPBUInt64DoubleDictionary *)dictionary {
5948  self = [self initWithDoubles:NULL forKeys:NULL count:0];
5949  if (self) {
5950    if (dictionary) {
5951      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
5952    }
5953  }
5954  return self;
5955}
5956
5957- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
5958  return [self initWithDoubles:NULL forKeys:NULL count:0];
5959}
5960
5961- (void)dealloc {
5962  NSAssert(!_autocreator,
5963           @"%@: Autocreator must be cleared before release, autocreator: %@",
5964           [self class], _autocreator);
5965  [_dictionary release];
5966  [super dealloc];
5967}
5968
5969- (instancetype)copyWithZone:(NSZone *)zone {
5970  return [[GPBUInt64DoubleDictionary allocWithZone:zone] initWithDictionary:self];
5971}
5972
5973- (BOOL)isEqual:(id)other {
5974  if (self == other) {
5975    return YES;
5976  }
5977  if (![other isKindOfClass:[GPBUInt64DoubleDictionary class]]) {
5978    return NO;
5979  }
5980  GPBUInt64DoubleDictionary *otherDictionary = other;
5981  return [_dictionary isEqual:otherDictionary->_dictionary];
5982}
5983
5984- (NSUInteger)hash {
5985  return _dictionary.count;
5986}
5987
5988- (NSString *)description {
5989  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
5990}
5991
5992- (NSUInteger)count {
5993  return _dictionary.count;
5994}
5995
5996- (void)enumerateKeysAndDoublesUsingBlock:
5997    (void (NS_NOESCAPE ^)(uint64_t key, double value, BOOL *stop))block {
5998  BOOL stop = NO;
5999  NSDictionary *internal = _dictionary;
6000  NSEnumerator *keys = [internal keyEnumerator];
6001  NSNumber *aKey;
6002  while ((aKey = [keys nextObject])) {
6003    NSNumber *aValue = internal[aKey];
6004    block([aKey unsignedLongLongValue], [aValue doubleValue], &stop);
6005    if (stop) {
6006      break;
6007    }
6008  }
6009}
6010
6011- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
6012  NSDictionary *internal = _dictionary;
6013  NSUInteger count = internal.count;
6014  if (count == 0) {
6015    return 0;
6016  }
6017
6018  GPBDataType valueDataType = GPBGetFieldDataType(field);
6019  GPBDataType keyDataType = field.mapKeyDataType;
6020  size_t result = 0;
6021  NSEnumerator *keys = [internal keyEnumerator];
6022  NSNumber *aKey;
6023  while ((aKey = [keys nextObject])) {
6024    NSNumber *aValue = internal[aKey];
6025    size_t msgSize = ComputeDictUInt64FieldSize([aKey unsignedLongLongValue], kMapKeyFieldNumber, keyDataType);
6026    msgSize += ComputeDictDoubleFieldSize([aValue doubleValue], kMapValueFieldNumber, valueDataType);
6027    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
6028  }
6029  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
6030  result += tagSize * count;
6031  return result;
6032}
6033
6034- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
6035                         asField:(GPBFieldDescriptor *)field {
6036  GPBDataType valueDataType = GPBGetFieldDataType(field);
6037  GPBDataType keyDataType = field.mapKeyDataType;
6038  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
6039  NSDictionary *internal = _dictionary;
6040  NSEnumerator *keys = [internal keyEnumerator];
6041  NSNumber *aKey;
6042  while ((aKey = [keys nextObject])) {
6043    NSNumber *aValue = internal[aKey];
6044    [outputStream writeInt32NoTag:tag];
6045    // Write the size of the message.
6046    uint64_t unwrappedKey = [aKey unsignedLongLongValue];
6047    double unwrappedValue = [aValue doubleValue];
6048    size_t msgSize = ComputeDictUInt64FieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
6049    msgSize += ComputeDictDoubleFieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
6050    [outputStream writeInt32NoTag:(int32_t)msgSize];
6051    // Write the fields.
6052    WriteDictUInt64Field(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
6053    WriteDictDoubleField(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
6054  }
6055}
6056
6057- (void)setGPBGenericValue:(GPBGenericValue *)value
6058     forGPBGenericValueKey:(GPBGenericValue *)key {
6059  [_dictionary setObject:@(value->valueDouble) forKey:@(key->valueUInt64)];
6060}
6061
6062- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
6063  [self enumerateKeysAndDoublesUsingBlock:^(uint64_t key, double value, __unused BOOL *stop) {
6064      block([NSString stringWithFormat:@"%llu", key], [NSString stringWithFormat:@"%.*lg", DBL_DIG, value]);
6065  }];
6066}
6067
6068- (BOOL)getDouble:(nullable double *)value forKey:(uint64_t)key {
6069  NSNumber *wrapped = [_dictionary objectForKey:@(key)];
6070  if (wrapped && value) {
6071    *value = [wrapped doubleValue];
6072  }
6073  return (wrapped != NULL);
6074}
6075
6076- (void)addEntriesFromDictionary:(GPBUInt64DoubleDictionary *)otherDictionary {
6077  if (otherDictionary) {
6078    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
6079    if (_autocreator) {
6080      GPBAutocreatedDictionaryModified(_autocreator, self);
6081    }
6082  }
6083}
6084
6085- (void)setDouble:(double)value forKey:(uint64_t)key {
6086  [_dictionary setObject:@(value) forKey:@(key)];
6087  if (_autocreator) {
6088    GPBAutocreatedDictionaryModified(_autocreator, self);
6089  }
6090}
6091
6092- (void)removeDoubleForKey:(uint64_t)aKey {
6093  [_dictionary removeObjectForKey:@(aKey)];
6094}
6095
6096- (void)removeAll {
6097  [_dictionary removeAllObjects];
6098}
6099
6100@end
6101
6102#pragma mark - UInt64 -> Enum
6103
6104@implementation GPBUInt64EnumDictionary {
6105 @package
6106  NSMutableDictionary *_dictionary;
6107  GPBEnumValidationFunc _validationFunc;
6108}
6109
6110@synthesize validationFunc = _validationFunc;
6111
6112- (instancetype)init {
6113  return [self initWithValidationFunction:NULL rawValues:NULL forKeys:NULL count:0];
6114}
6115
6116- (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func {
6117  return [self initWithValidationFunction:func rawValues:NULL forKeys:NULL count:0];
6118}
6119
6120- (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func
6121                                 rawValues:(const int32_t [])rawValues
6122                                   forKeys:(const uint64_t [])keys
6123                                     count:(NSUInteger)count {
6124  self = [super init];
6125  if (self) {
6126    _dictionary = [[NSMutableDictionary alloc] init];
6127    _validationFunc = (func != NULL ? func : DictDefault_IsValidValue);
6128    if (count && rawValues && keys) {
6129      for (NSUInteger i = 0; i < count; ++i) {
6130        [_dictionary setObject:@(rawValues[i]) forKey:@(keys[i])];
6131      }
6132    }
6133  }
6134  return self;
6135}
6136
6137- (instancetype)initWithDictionary:(GPBUInt64EnumDictionary *)dictionary {
6138  self = [self initWithValidationFunction:dictionary.validationFunc
6139                                rawValues:NULL
6140                                  forKeys:NULL
6141                                    count:0];
6142  if (self) {
6143    if (dictionary) {
6144      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
6145    }
6146  }
6147  return self;
6148}
6149
6150- (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func
6151                                  capacity:(__unused NSUInteger)numItems {
6152  return [self initWithValidationFunction:func rawValues:NULL forKeys:NULL count:0];
6153}
6154
6155- (void)dealloc {
6156  NSAssert(!_autocreator,
6157           @"%@: Autocreator must be cleared before release, autocreator: %@",
6158           [self class], _autocreator);
6159  [_dictionary release];
6160  [super dealloc];
6161}
6162
6163- (instancetype)copyWithZone:(NSZone *)zone {
6164  return [[GPBUInt64EnumDictionary allocWithZone:zone] initWithDictionary:self];
6165}
6166
6167- (BOOL)isEqual:(id)other {
6168  if (self == other) {
6169    return YES;
6170  }
6171  if (![other isKindOfClass:[GPBUInt64EnumDictionary class]]) {
6172    return NO;
6173  }
6174  GPBUInt64EnumDictionary *otherDictionary = other;
6175  return [_dictionary isEqual:otherDictionary->_dictionary];
6176}
6177
6178- (NSUInteger)hash {
6179  return _dictionary.count;
6180}
6181
6182- (NSString *)description {
6183  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
6184}
6185
6186- (NSUInteger)count {
6187  return _dictionary.count;
6188}
6189
6190- (void)enumerateKeysAndRawValuesUsingBlock:
6191    (void (NS_NOESCAPE ^)(uint64_t key, int32_t value, BOOL *stop))block {
6192  BOOL stop = NO;
6193  NSDictionary *internal = _dictionary;
6194  NSEnumerator *keys = [internal keyEnumerator];
6195  NSNumber *aKey;
6196  while ((aKey = [keys nextObject])) {
6197    NSNumber *aValue = internal[aKey];
6198    block([aKey unsignedLongLongValue], [aValue intValue], &stop);
6199    if (stop) {
6200      break;
6201    }
6202  }
6203}
6204
6205- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
6206  NSDictionary *internal = _dictionary;
6207  NSUInteger count = internal.count;
6208  if (count == 0) {
6209    return 0;
6210  }
6211
6212  GPBDataType valueDataType = GPBGetFieldDataType(field);
6213  GPBDataType keyDataType = field.mapKeyDataType;
6214  size_t result = 0;
6215  NSEnumerator *keys = [internal keyEnumerator];
6216  NSNumber *aKey;
6217  while ((aKey = [keys nextObject])) {
6218    NSNumber *aValue = internal[aKey];
6219    size_t msgSize = ComputeDictUInt64FieldSize([aKey unsignedLongLongValue], kMapKeyFieldNumber, keyDataType);
6220    msgSize += ComputeDictEnumFieldSize([aValue intValue], kMapValueFieldNumber, valueDataType);
6221    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
6222  }
6223  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
6224  result += tagSize * count;
6225  return result;
6226}
6227
6228- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
6229                         asField:(GPBFieldDescriptor *)field {
6230  GPBDataType valueDataType = GPBGetFieldDataType(field);
6231  GPBDataType keyDataType = field.mapKeyDataType;
6232  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
6233  NSDictionary *internal = _dictionary;
6234  NSEnumerator *keys = [internal keyEnumerator];
6235  NSNumber *aKey;
6236  while ((aKey = [keys nextObject])) {
6237    NSNumber *aValue = internal[aKey];
6238    [outputStream writeInt32NoTag:tag];
6239    // Write the size of the message.
6240    uint64_t unwrappedKey = [aKey unsignedLongLongValue];
6241    int32_t unwrappedValue = [aValue intValue];
6242    size_t msgSize = ComputeDictUInt64FieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
6243    msgSize += ComputeDictEnumFieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
6244    [outputStream writeInt32NoTag:(int32_t)msgSize];
6245    // Write the fields.
6246    WriteDictUInt64Field(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
6247    WriteDictEnumField(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
6248  }
6249}
6250
6251- (NSData *)serializedDataForUnknownValue:(int32_t)value
6252                                   forKey:(GPBGenericValue *)key
6253                              keyDataType:(GPBDataType)keyDataType {
6254  size_t msgSize = ComputeDictUInt64FieldSize(key->valueUInt64, kMapKeyFieldNumber, keyDataType);
6255  msgSize += ComputeDictEnumFieldSize(value, kMapValueFieldNumber, GPBDataTypeEnum);
6256  NSMutableData *data = [NSMutableData dataWithLength:msgSize];
6257  GPBCodedOutputStream *outputStream = [[GPBCodedOutputStream alloc] initWithData:data];
6258  WriteDictUInt64Field(outputStream, key->valueUInt64, kMapKeyFieldNumber, keyDataType);
6259  WriteDictEnumField(outputStream, value, kMapValueFieldNumber, GPBDataTypeEnum);
6260  [outputStream flush];
6261  [outputStream release];
6262  return data;
6263}
6264- (void)setGPBGenericValue:(GPBGenericValue *)value
6265     forGPBGenericValueKey:(GPBGenericValue *)key {
6266  [_dictionary setObject:@(value->valueEnum) forKey:@(key->valueUInt64)];
6267}
6268
6269- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
6270  [self enumerateKeysAndRawValuesUsingBlock:^(uint64_t key, int32_t value, __unused BOOL *stop) {
6271      block([NSString stringWithFormat:@"%llu", key], @(value));
6272  }];
6273}
6274
6275- (BOOL)getEnum:(int32_t *)value forKey:(uint64_t)key {
6276  NSNumber *wrapped = [_dictionary objectForKey:@(key)];
6277  if (wrapped && value) {
6278    int32_t result = [wrapped intValue];
6279    if (!_validationFunc(result)) {
6280      result = kGPBUnrecognizedEnumeratorValue;
6281    }
6282    *value = result;
6283  }
6284  return (wrapped != NULL);
6285}
6286
6287- (BOOL)getRawValue:(int32_t *)rawValue forKey:(uint64_t)key {
6288  NSNumber *wrapped = [_dictionary objectForKey:@(key)];
6289  if (wrapped && rawValue) {
6290    *rawValue = [wrapped intValue];
6291  }
6292  return (wrapped != NULL);
6293}
6294
6295- (void)enumerateKeysAndEnumsUsingBlock:
6296    (void (NS_NOESCAPE ^)(uint64_t key, int32_t value, BOOL *stop))block {
6297  GPBEnumValidationFunc func = _validationFunc;
6298  BOOL stop = NO;
6299  NSEnumerator *keys = [_dictionary keyEnumerator];
6300  NSNumber *aKey;
6301  while ((aKey = [keys nextObject])) {
6302    NSNumber *aValue = _dictionary[aKey];
6303      int32_t unwrapped = [aValue intValue];
6304      if (!func(unwrapped)) {
6305        unwrapped = kGPBUnrecognizedEnumeratorValue;
6306      }
6307    block([aKey unsignedLongLongValue], unwrapped, &stop);
6308    if (stop) {
6309      break;
6310    }
6311  }
6312}
6313
6314- (void)addRawEntriesFromDictionary:(GPBUInt64EnumDictionary *)otherDictionary {
6315  if (otherDictionary) {
6316    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
6317    if (_autocreator) {
6318      GPBAutocreatedDictionaryModified(_autocreator, self);
6319    }
6320  }
6321}
6322
6323- (void)setRawValue:(int32_t)value forKey:(uint64_t)key {
6324  [_dictionary setObject:@(value) forKey:@(key)];
6325  if (_autocreator) {
6326    GPBAutocreatedDictionaryModified(_autocreator, self);
6327  }
6328}
6329
6330- (void)removeEnumForKey:(uint64_t)aKey {
6331  [_dictionary removeObjectForKey:@(aKey)];
6332}
6333
6334- (void)removeAll {
6335  [_dictionary removeAllObjects];
6336}
6337
6338- (void)setEnum:(int32_t)value forKey:(uint64_t)key {
6339  if (!_validationFunc(value)) {
6340    [NSException raise:NSInvalidArgumentException
6341                format:@"GPBUInt64EnumDictionary: Attempt to set an unknown enum value (%d)",
6342                       value];
6343  }
6344
6345  [_dictionary setObject:@(value) forKey:@(key)];
6346  if (_autocreator) {
6347    GPBAutocreatedDictionaryModified(_autocreator, self);
6348  }
6349}
6350
6351@end
6352
6353#pragma mark - UInt64 -> Object
6354
6355@implementation GPBUInt64ObjectDictionary {
6356 @package
6357  NSMutableDictionary *_dictionary;
6358}
6359
6360- (instancetype)init {
6361  return [self initWithObjects:NULL forKeys:NULL count:0];
6362}
6363
6364- (instancetype)initWithObjects:(const id [])objects
6365                        forKeys:(const uint64_t [])keys
6366                          count:(NSUInteger)count {
6367  self = [super init];
6368  if (self) {
6369    _dictionary = [[NSMutableDictionary alloc] init];
6370    if (count && objects && keys) {
6371      for (NSUInteger i = 0; i < count; ++i) {
6372        if (!objects[i]) {
6373          [NSException raise:NSInvalidArgumentException
6374                      format:@"Attempting to add nil object to a Dictionary"];
6375        }
6376        [_dictionary setObject:objects[i] forKey:@(keys[i])];
6377      }
6378    }
6379  }
6380  return self;
6381}
6382
6383- (instancetype)initWithDictionary:(GPBUInt64ObjectDictionary *)dictionary {
6384  self = [self initWithObjects:NULL forKeys:NULL count:0];
6385  if (self) {
6386    if (dictionary) {
6387      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
6388    }
6389  }
6390  return self;
6391}
6392
6393- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
6394  return [self initWithObjects:NULL forKeys:NULL count:0];
6395}
6396
6397- (void)dealloc {
6398  NSAssert(!_autocreator,
6399           @"%@: Autocreator must be cleared before release, autocreator: %@",
6400           [self class], _autocreator);
6401  [_dictionary release];
6402  [super dealloc];
6403}
6404
6405- (instancetype)copyWithZone:(NSZone *)zone {
6406  return [[GPBUInt64ObjectDictionary allocWithZone:zone] initWithDictionary:self];
6407}
6408
6409- (BOOL)isEqual:(id)other {
6410  if (self == other) {
6411    return YES;
6412  }
6413  if (![other isKindOfClass:[GPBUInt64ObjectDictionary class]]) {
6414    return NO;
6415  }
6416  GPBUInt64ObjectDictionary *otherDictionary = other;
6417  return [_dictionary isEqual:otherDictionary->_dictionary];
6418}
6419
6420- (NSUInteger)hash {
6421  return _dictionary.count;
6422}
6423
6424- (NSString *)description {
6425  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
6426}
6427
6428- (NSUInteger)count {
6429  return _dictionary.count;
6430}
6431
6432- (void)enumerateKeysAndObjectsUsingBlock:
6433    (void (NS_NOESCAPE ^)(uint64_t key, id object, BOOL *stop))block {
6434  BOOL stop = NO;
6435  NSDictionary *internal = _dictionary;
6436  NSEnumerator *keys = [internal keyEnumerator];
6437  NSNumber *aKey;
6438  while ((aKey = [keys nextObject])) {
6439    id aObject = internal[aKey];
6440    block([aKey unsignedLongLongValue], aObject, &stop);
6441    if (stop) {
6442      break;
6443    }
6444  }
6445}
6446
6447- (BOOL)isInitialized {
6448  for (GPBMessage *msg in [_dictionary objectEnumerator]) {
6449    if (!msg.initialized) {
6450      return NO;
6451    }
6452  }
6453  return YES;
6454}
6455
6456- (instancetype)deepCopyWithZone:(NSZone *)zone {
6457  GPBUInt64ObjectDictionary *newDict =
6458      [[GPBUInt64ObjectDictionary alloc] init];
6459  NSEnumerator *keys = [_dictionary keyEnumerator];
6460  id aKey;
6461  NSMutableDictionary *internalDict = newDict->_dictionary;
6462  while ((aKey = [keys nextObject])) {
6463    GPBMessage *msg = _dictionary[aKey];
6464    GPBMessage *copiedMsg = [msg copyWithZone:zone];
6465    [internalDict setObject:copiedMsg forKey:aKey];
6466    [copiedMsg release];
6467  }
6468  return newDict;
6469}
6470
6471- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
6472  NSDictionary *internal = _dictionary;
6473  NSUInteger count = internal.count;
6474  if (count == 0) {
6475    return 0;
6476  }
6477
6478  GPBDataType valueDataType = GPBGetFieldDataType(field);
6479  GPBDataType keyDataType = field.mapKeyDataType;
6480  size_t result = 0;
6481  NSEnumerator *keys = [internal keyEnumerator];
6482  NSNumber *aKey;
6483  while ((aKey = [keys nextObject])) {
6484    id aObject = internal[aKey];
6485    size_t msgSize = ComputeDictUInt64FieldSize([aKey unsignedLongLongValue], kMapKeyFieldNumber, keyDataType);
6486    msgSize += ComputeDictObjectFieldSize(aObject, kMapValueFieldNumber, valueDataType);
6487    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
6488  }
6489  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
6490  result += tagSize * count;
6491  return result;
6492}
6493
6494- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
6495                         asField:(GPBFieldDescriptor *)field {
6496  GPBDataType valueDataType = GPBGetFieldDataType(field);
6497  GPBDataType keyDataType = field.mapKeyDataType;
6498  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
6499  NSDictionary *internal = _dictionary;
6500  NSEnumerator *keys = [internal keyEnumerator];
6501  NSNumber *aKey;
6502  while ((aKey = [keys nextObject])) {
6503    id aObject = internal[aKey];
6504    [outputStream writeInt32NoTag:tag];
6505    // Write the size of the message.
6506    uint64_t unwrappedKey = [aKey unsignedLongLongValue];
6507    id unwrappedValue = aObject;
6508    size_t msgSize = ComputeDictUInt64FieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
6509    msgSize += ComputeDictObjectFieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
6510    [outputStream writeInt32NoTag:(int32_t)msgSize];
6511    // Write the fields.
6512    WriteDictUInt64Field(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
6513    WriteDictObjectField(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
6514  }
6515}
6516
6517- (void)setGPBGenericValue:(GPBGenericValue *)value
6518     forGPBGenericValueKey:(GPBGenericValue *)key {
6519  [_dictionary setObject:value->valueString forKey:@(key->valueUInt64)];
6520}
6521
6522- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
6523  [self enumerateKeysAndObjectsUsingBlock:^(uint64_t key, id object, __unused BOOL *stop) {
6524      block([NSString stringWithFormat:@"%llu", key], object);
6525  }];
6526}
6527
6528- (id)objectForKey:(uint64_t)key {
6529  id result = [_dictionary objectForKey:@(key)];
6530  return result;
6531}
6532
6533- (void)addEntriesFromDictionary:(GPBUInt64ObjectDictionary *)otherDictionary {
6534  if (otherDictionary) {
6535    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
6536    if (_autocreator) {
6537      GPBAutocreatedDictionaryModified(_autocreator, self);
6538    }
6539  }
6540}
6541
6542- (void)setObject:(id)object forKey:(uint64_t)key {
6543  if (!object) {
6544    [NSException raise:NSInvalidArgumentException
6545                format:@"Attempting to add nil object to a Dictionary"];
6546  }
6547  [_dictionary setObject:object forKey:@(key)];
6548  if (_autocreator) {
6549    GPBAutocreatedDictionaryModified(_autocreator, self);
6550  }
6551}
6552
6553- (void)removeObjectForKey:(uint64_t)aKey {
6554  [_dictionary removeObjectForKey:@(aKey)];
6555}
6556
6557- (void)removeAll {
6558  [_dictionary removeAllObjects];
6559}
6560
6561@end
6562
6563//%PDDM-EXPAND DICTIONARY_IMPL_FOR_POD_KEY(Int64, int64_t)
6564// This block of code is generated, do not edit it directly.
6565
6566#pragma mark - Int64 -> UInt32
6567
6568@implementation GPBInt64UInt32Dictionary {
6569 @package
6570  NSMutableDictionary *_dictionary;
6571}
6572
6573- (instancetype)init {
6574  return [self initWithUInt32s:NULL forKeys:NULL count:0];
6575}
6576
6577- (instancetype)initWithUInt32s:(const uint32_t [])values
6578                        forKeys:(const int64_t [])keys
6579                          count:(NSUInteger)count {
6580  self = [super init];
6581  if (self) {
6582    _dictionary = [[NSMutableDictionary alloc] init];
6583    if (count && values && keys) {
6584      for (NSUInteger i = 0; i < count; ++i) {
6585        [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
6586      }
6587    }
6588  }
6589  return self;
6590}
6591
6592- (instancetype)initWithDictionary:(GPBInt64UInt32Dictionary *)dictionary {
6593  self = [self initWithUInt32s:NULL forKeys:NULL count:0];
6594  if (self) {
6595    if (dictionary) {
6596      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
6597    }
6598  }
6599  return self;
6600}
6601
6602- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
6603  return [self initWithUInt32s:NULL forKeys:NULL count:0];
6604}
6605
6606- (void)dealloc {
6607  NSAssert(!_autocreator,
6608           @"%@: Autocreator must be cleared before release, autocreator: %@",
6609           [self class], _autocreator);
6610  [_dictionary release];
6611  [super dealloc];
6612}
6613
6614- (instancetype)copyWithZone:(NSZone *)zone {
6615  return [[GPBInt64UInt32Dictionary allocWithZone:zone] initWithDictionary:self];
6616}
6617
6618- (BOOL)isEqual:(id)other {
6619  if (self == other) {
6620    return YES;
6621  }
6622  if (![other isKindOfClass:[GPBInt64UInt32Dictionary class]]) {
6623    return NO;
6624  }
6625  GPBInt64UInt32Dictionary *otherDictionary = other;
6626  return [_dictionary isEqual:otherDictionary->_dictionary];
6627}
6628
6629- (NSUInteger)hash {
6630  return _dictionary.count;
6631}
6632
6633- (NSString *)description {
6634  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
6635}
6636
6637- (NSUInteger)count {
6638  return _dictionary.count;
6639}
6640
6641- (void)enumerateKeysAndUInt32sUsingBlock:
6642    (void (NS_NOESCAPE ^)(int64_t key, uint32_t value, BOOL *stop))block {
6643  BOOL stop = NO;
6644  NSDictionary *internal = _dictionary;
6645  NSEnumerator *keys = [internal keyEnumerator];
6646  NSNumber *aKey;
6647  while ((aKey = [keys nextObject])) {
6648    NSNumber *aValue = internal[aKey];
6649    block([aKey longLongValue], [aValue unsignedIntValue], &stop);
6650    if (stop) {
6651      break;
6652    }
6653  }
6654}
6655
6656- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
6657  NSDictionary *internal = _dictionary;
6658  NSUInteger count = internal.count;
6659  if (count == 0) {
6660    return 0;
6661  }
6662
6663  GPBDataType valueDataType = GPBGetFieldDataType(field);
6664  GPBDataType keyDataType = field.mapKeyDataType;
6665  size_t result = 0;
6666  NSEnumerator *keys = [internal keyEnumerator];
6667  NSNumber *aKey;
6668  while ((aKey = [keys nextObject])) {
6669    NSNumber *aValue = internal[aKey];
6670    size_t msgSize = ComputeDictInt64FieldSize([aKey longLongValue], kMapKeyFieldNumber, keyDataType);
6671    msgSize += ComputeDictUInt32FieldSize([aValue unsignedIntValue], kMapValueFieldNumber, valueDataType);
6672    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
6673  }
6674  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
6675  result += tagSize * count;
6676  return result;
6677}
6678
6679- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
6680                         asField:(GPBFieldDescriptor *)field {
6681  GPBDataType valueDataType = GPBGetFieldDataType(field);
6682  GPBDataType keyDataType = field.mapKeyDataType;
6683  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
6684  NSDictionary *internal = _dictionary;
6685  NSEnumerator *keys = [internal keyEnumerator];
6686  NSNumber *aKey;
6687  while ((aKey = [keys nextObject])) {
6688    NSNumber *aValue = internal[aKey];
6689    [outputStream writeInt32NoTag:tag];
6690    // Write the size of the message.
6691    int64_t unwrappedKey = [aKey longLongValue];
6692    uint32_t unwrappedValue = [aValue unsignedIntValue];
6693    size_t msgSize = ComputeDictInt64FieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
6694    msgSize += ComputeDictUInt32FieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
6695    [outputStream writeInt32NoTag:(int32_t)msgSize];
6696    // Write the fields.
6697    WriteDictInt64Field(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
6698    WriteDictUInt32Field(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
6699  }
6700}
6701
6702- (void)setGPBGenericValue:(GPBGenericValue *)value
6703     forGPBGenericValueKey:(GPBGenericValue *)key {
6704  [_dictionary setObject:@(value->valueUInt32) forKey:@(key->valueInt64)];
6705}
6706
6707- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
6708  [self enumerateKeysAndUInt32sUsingBlock:^(int64_t key, uint32_t value, __unused BOOL *stop) {
6709      block([NSString stringWithFormat:@"%lld", key], [NSString stringWithFormat:@"%u", value]);
6710  }];
6711}
6712
6713- (BOOL)getUInt32:(nullable uint32_t *)value forKey:(int64_t)key {
6714  NSNumber *wrapped = [_dictionary objectForKey:@(key)];
6715  if (wrapped && value) {
6716    *value = [wrapped unsignedIntValue];
6717  }
6718  return (wrapped != NULL);
6719}
6720
6721- (void)addEntriesFromDictionary:(GPBInt64UInt32Dictionary *)otherDictionary {
6722  if (otherDictionary) {
6723    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
6724    if (_autocreator) {
6725      GPBAutocreatedDictionaryModified(_autocreator, self);
6726    }
6727  }
6728}
6729
6730- (void)setUInt32:(uint32_t)value forKey:(int64_t)key {
6731  [_dictionary setObject:@(value) forKey:@(key)];
6732  if (_autocreator) {
6733    GPBAutocreatedDictionaryModified(_autocreator, self);
6734  }
6735}
6736
6737- (void)removeUInt32ForKey:(int64_t)aKey {
6738  [_dictionary removeObjectForKey:@(aKey)];
6739}
6740
6741- (void)removeAll {
6742  [_dictionary removeAllObjects];
6743}
6744
6745@end
6746
6747#pragma mark - Int64 -> Int32
6748
6749@implementation GPBInt64Int32Dictionary {
6750 @package
6751  NSMutableDictionary *_dictionary;
6752}
6753
6754- (instancetype)init {
6755  return [self initWithInt32s:NULL forKeys:NULL count:0];
6756}
6757
6758- (instancetype)initWithInt32s:(const int32_t [])values
6759                       forKeys:(const int64_t [])keys
6760                         count:(NSUInteger)count {
6761  self = [super init];
6762  if (self) {
6763    _dictionary = [[NSMutableDictionary alloc] init];
6764    if (count && values && keys) {
6765      for (NSUInteger i = 0; i < count; ++i) {
6766        [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
6767      }
6768    }
6769  }
6770  return self;
6771}
6772
6773- (instancetype)initWithDictionary:(GPBInt64Int32Dictionary *)dictionary {
6774  self = [self initWithInt32s:NULL forKeys:NULL count:0];
6775  if (self) {
6776    if (dictionary) {
6777      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
6778    }
6779  }
6780  return self;
6781}
6782
6783- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
6784  return [self initWithInt32s:NULL forKeys:NULL count:0];
6785}
6786
6787- (void)dealloc {
6788  NSAssert(!_autocreator,
6789           @"%@: Autocreator must be cleared before release, autocreator: %@",
6790           [self class], _autocreator);
6791  [_dictionary release];
6792  [super dealloc];
6793}
6794
6795- (instancetype)copyWithZone:(NSZone *)zone {
6796  return [[GPBInt64Int32Dictionary allocWithZone:zone] initWithDictionary:self];
6797}
6798
6799- (BOOL)isEqual:(id)other {
6800  if (self == other) {
6801    return YES;
6802  }
6803  if (![other isKindOfClass:[GPBInt64Int32Dictionary class]]) {
6804    return NO;
6805  }
6806  GPBInt64Int32Dictionary *otherDictionary = other;
6807  return [_dictionary isEqual:otherDictionary->_dictionary];
6808}
6809
6810- (NSUInteger)hash {
6811  return _dictionary.count;
6812}
6813
6814- (NSString *)description {
6815  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
6816}
6817
6818- (NSUInteger)count {
6819  return _dictionary.count;
6820}
6821
6822- (void)enumerateKeysAndInt32sUsingBlock:
6823    (void (NS_NOESCAPE ^)(int64_t key, int32_t value, BOOL *stop))block {
6824  BOOL stop = NO;
6825  NSDictionary *internal = _dictionary;
6826  NSEnumerator *keys = [internal keyEnumerator];
6827  NSNumber *aKey;
6828  while ((aKey = [keys nextObject])) {
6829    NSNumber *aValue = internal[aKey];
6830    block([aKey longLongValue], [aValue intValue], &stop);
6831    if (stop) {
6832      break;
6833    }
6834  }
6835}
6836
6837- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
6838  NSDictionary *internal = _dictionary;
6839  NSUInteger count = internal.count;
6840  if (count == 0) {
6841    return 0;
6842  }
6843
6844  GPBDataType valueDataType = GPBGetFieldDataType(field);
6845  GPBDataType keyDataType = field.mapKeyDataType;
6846  size_t result = 0;
6847  NSEnumerator *keys = [internal keyEnumerator];
6848  NSNumber *aKey;
6849  while ((aKey = [keys nextObject])) {
6850    NSNumber *aValue = internal[aKey];
6851    size_t msgSize = ComputeDictInt64FieldSize([aKey longLongValue], kMapKeyFieldNumber, keyDataType);
6852    msgSize += ComputeDictInt32FieldSize([aValue intValue], kMapValueFieldNumber, valueDataType);
6853    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
6854  }
6855  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
6856  result += tagSize * count;
6857  return result;
6858}
6859
6860- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
6861                         asField:(GPBFieldDescriptor *)field {
6862  GPBDataType valueDataType = GPBGetFieldDataType(field);
6863  GPBDataType keyDataType = field.mapKeyDataType;
6864  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
6865  NSDictionary *internal = _dictionary;
6866  NSEnumerator *keys = [internal keyEnumerator];
6867  NSNumber *aKey;
6868  while ((aKey = [keys nextObject])) {
6869    NSNumber *aValue = internal[aKey];
6870    [outputStream writeInt32NoTag:tag];
6871    // Write the size of the message.
6872    int64_t unwrappedKey = [aKey longLongValue];
6873    int32_t unwrappedValue = [aValue intValue];
6874    size_t msgSize = ComputeDictInt64FieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
6875    msgSize += ComputeDictInt32FieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
6876    [outputStream writeInt32NoTag:(int32_t)msgSize];
6877    // Write the fields.
6878    WriteDictInt64Field(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
6879    WriteDictInt32Field(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
6880  }
6881}
6882
6883- (void)setGPBGenericValue:(GPBGenericValue *)value
6884     forGPBGenericValueKey:(GPBGenericValue *)key {
6885  [_dictionary setObject:@(value->valueInt32) forKey:@(key->valueInt64)];
6886}
6887
6888- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
6889  [self enumerateKeysAndInt32sUsingBlock:^(int64_t key, int32_t value, __unused BOOL *stop) {
6890      block([NSString stringWithFormat:@"%lld", key], [NSString stringWithFormat:@"%d", value]);
6891  }];
6892}
6893
6894- (BOOL)getInt32:(nullable int32_t *)value forKey:(int64_t)key {
6895  NSNumber *wrapped = [_dictionary objectForKey:@(key)];
6896  if (wrapped && value) {
6897    *value = [wrapped intValue];
6898  }
6899  return (wrapped != NULL);
6900}
6901
6902- (void)addEntriesFromDictionary:(GPBInt64Int32Dictionary *)otherDictionary {
6903  if (otherDictionary) {
6904    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
6905    if (_autocreator) {
6906      GPBAutocreatedDictionaryModified(_autocreator, self);
6907    }
6908  }
6909}
6910
6911- (void)setInt32:(int32_t)value forKey:(int64_t)key {
6912  [_dictionary setObject:@(value) forKey:@(key)];
6913  if (_autocreator) {
6914    GPBAutocreatedDictionaryModified(_autocreator, self);
6915  }
6916}
6917
6918- (void)removeInt32ForKey:(int64_t)aKey {
6919  [_dictionary removeObjectForKey:@(aKey)];
6920}
6921
6922- (void)removeAll {
6923  [_dictionary removeAllObjects];
6924}
6925
6926@end
6927
6928#pragma mark - Int64 -> UInt64
6929
6930@implementation GPBInt64UInt64Dictionary {
6931 @package
6932  NSMutableDictionary *_dictionary;
6933}
6934
6935- (instancetype)init {
6936  return [self initWithUInt64s:NULL forKeys:NULL count:0];
6937}
6938
6939- (instancetype)initWithUInt64s:(const uint64_t [])values
6940                        forKeys:(const int64_t [])keys
6941                          count:(NSUInteger)count {
6942  self = [super init];
6943  if (self) {
6944    _dictionary = [[NSMutableDictionary alloc] init];
6945    if (count && values && keys) {
6946      for (NSUInteger i = 0; i < count; ++i) {
6947        [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
6948      }
6949    }
6950  }
6951  return self;
6952}
6953
6954- (instancetype)initWithDictionary:(GPBInt64UInt64Dictionary *)dictionary {
6955  self = [self initWithUInt64s:NULL forKeys:NULL count:0];
6956  if (self) {
6957    if (dictionary) {
6958      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
6959    }
6960  }
6961  return self;
6962}
6963
6964- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
6965  return [self initWithUInt64s:NULL forKeys:NULL count:0];
6966}
6967
6968- (void)dealloc {
6969  NSAssert(!_autocreator,
6970           @"%@: Autocreator must be cleared before release, autocreator: %@",
6971           [self class], _autocreator);
6972  [_dictionary release];
6973  [super dealloc];
6974}
6975
6976- (instancetype)copyWithZone:(NSZone *)zone {
6977  return [[GPBInt64UInt64Dictionary allocWithZone:zone] initWithDictionary:self];
6978}
6979
6980- (BOOL)isEqual:(id)other {
6981  if (self == other) {
6982    return YES;
6983  }
6984  if (![other isKindOfClass:[GPBInt64UInt64Dictionary class]]) {
6985    return NO;
6986  }
6987  GPBInt64UInt64Dictionary *otherDictionary = other;
6988  return [_dictionary isEqual:otherDictionary->_dictionary];
6989}
6990
6991- (NSUInteger)hash {
6992  return _dictionary.count;
6993}
6994
6995- (NSString *)description {
6996  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
6997}
6998
6999- (NSUInteger)count {
7000  return _dictionary.count;
7001}
7002
7003- (void)enumerateKeysAndUInt64sUsingBlock:
7004    (void (NS_NOESCAPE ^)(int64_t key, uint64_t value, BOOL *stop))block {
7005  BOOL stop = NO;
7006  NSDictionary *internal = _dictionary;
7007  NSEnumerator *keys = [internal keyEnumerator];
7008  NSNumber *aKey;
7009  while ((aKey = [keys nextObject])) {
7010    NSNumber *aValue = internal[aKey];
7011    block([aKey longLongValue], [aValue unsignedLongLongValue], &stop);
7012    if (stop) {
7013      break;
7014    }
7015  }
7016}
7017
7018- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
7019  NSDictionary *internal = _dictionary;
7020  NSUInteger count = internal.count;
7021  if (count == 0) {
7022    return 0;
7023  }
7024
7025  GPBDataType valueDataType = GPBGetFieldDataType(field);
7026  GPBDataType keyDataType = field.mapKeyDataType;
7027  size_t result = 0;
7028  NSEnumerator *keys = [internal keyEnumerator];
7029  NSNumber *aKey;
7030  while ((aKey = [keys nextObject])) {
7031    NSNumber *aValue = internal[aKey];
7032    size_t msgSize = ComputeDictInt64FieldSize([aKey longLongValue], kMapKeyFieldNumber, keyDataType);
7033    msgSize += ComputeDictUInt64FieldSize([aValue unsignedLongLongValue], kMapValueFieldNumber, valueDataType);
7034    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
7035  }
7036  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
7037  result += tagSize * count;
7038  return result;
7039}
7040
7041- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
7042                         asField:(GPBFieldDescriptor *)field {
7043  GPBDataType valueDataType = GPBGetFieldDataType(field);
7044  GPBDataType keyDataType = field.mapKeyDataType;
7045  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
7046  NSDictionary *internal = _dictionary;
7047  NSEnumerator *keys = [internal keyEnumerator];
7048  NSNumber *aKey;
7049  while ((aKey = [keys nextObject])) {
7050    NSNumber *aValue = internal[aKey];
7051    [outputStream writeInt32NoTag:tag];
7052    // Write the size of the message.
7053    int64_t unwrappedKey = [aKey longLongValue];
7054    uint64_t unwrappedValue = [aValue unsignedLongLongValue];
7055    size_t msgSize = ComputeDictInt64FieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
7056    msgSize += ComputeDictUInt64FieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
7057    [outputStream writeInt32NoTag:(int32_t)msgSize];
7058    // Write the fields.
7059    WriteDictInt64Field(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
7060    WriteDictUInt64Field(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
7061  }
7062}
7063
7064- (void)setGPBGenericValue:(GPBGenericValue *)value
7065     forGPBGenericValueKey:(GPBGenericValue *)key {
7066  [_dictionary setObject:@(value->valueUInt64) forKey:@(key->valueInt64)];
7067}
7068
7069- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
7070  [self enumerateKeysAndUInt64sUsingBlock:^(int64_t key, uint64_t value, __unused BOOL *stop) {
7071      block([NSString stringWithFormat:@"%lld", key], [NSString stringWithFormat:@"%llu", value]);
7072  }];
7073}
7074
7075- (BOOL)getUInt64:(nullable uint64_t *)value forKey:(int64_t)key {
7076  NSNumber *wrapped = [_dictionary objectForKey:@(key)];
7077  if (wrapped && value) {
7078    *value = [wrapped unsignedLongLongValue];
7079  }
7080  return (wrapped != NULL);
7081}
7082
7083- (void)addEntriesFromDictionary:(GPBInt64UInt64Dictionary *)otherDictionary {
7084  if (otherDictionary) {
7085    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
7086    if (_autocreator) {
7087      GPBAutocreatedDictionaryModified(_autocreator, self);
7088    }
7089  }
7090}
7091
7092- (void)setUInt64:(uint64_t)value forKey:(int64_t)key {
7093  [_dictionary setObject:@(value) forKey:@(key)];
7094  if (_autocreator) {
7095    GPBAutocreatedDictionaryModified(_autocreator, self);
7096  }
7097}
7098
7099- (void)removeUInt64ForKey:(int64_t)aKey {
7100  [_dictionary removeObjectForKey:@(aKey)];
7101}
7102
7103- (void)removeAll {
7104  [_dictionary removeAllObjects];
7105}
7106
7107@end
7108
7109#pragma mark - Int64 -> Int64
7110
7111@implementation GPBInt64Int64Dictionary {
7112 @package
7113  NSMutableDictionary *_dictionary;
7114}
7115
7116- (instancetype)init {
7117  return [self initWithInt64s:NULL forKeys:NULL count:0];
7118}
7119
7120- (instancetype)initWithInt64s:(const int64_t [])values
7121                       forKeys:(const int64_t [])keys
7122                         count:(NSUInteger)count {
7123  self = [super init];
7124  if (self) {
7125    _dictionary = [[NSMutableDictionary alloc] init];
7126    if (count && values && keys) {
7127      for (NSUInteger i = 0; i < count; ++i) {
7128        [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
7129      }
7130    }
7131  }
7132  return self;
7133}
7134
7135- (instancetype)initWithDictionary:(GPBInt64Int64Dictionary *)dictionary {
7136  self = [self initWithInt64s:NULL forKeys:NULL count:0];
7137  if (self) {
7138    if (dictionary) {
7139      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
7140    }
7141  }
7142  return self;
7143}
7144
7145- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
7146  return [self initWithInt64s:NULL forKeys:NULL count:0];
7147}
7148
7149- (void)dealloc {
7150  NSAssert(!_autocreator,
7151           @"%@: Autocreator must be cleared before release, autocreator: %@",
7152           [self class], _autocreator);
7153  [_dictionary release];
7154  [super dealloc];
7155}
7156
7157- (instancetype)copyWithZone:(NSZone *)zone {
7158  return [[GPBInt64Int64Dictionary allocWithZone:zone] initWithDictionary:self];
7159}
7160
7161- (BOOL)isEqual:(id)other {
7162  if (self == other) {
7163    return YES;
7164  }
7165  if (![other isKindOfClass:[GPBInt64Int64Dictionary class]]) {
7166    return NO;
7167  }
7168  GPBInt64Int64Dictionary *otherDictionary = other;
7169  return [_dictionary isEqual:otherDictionary->_dictionary];
7170}
7171
7172- (NSUInteger)hash {
7173  return _dictionary.count;
7174}
7175
7176- (NSString *)description {
7177  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
7178}
7179
7180- (NSUInteger)count {
7181  return _dictionary.count;
7182}
7183
7184- (void)enumerateKeysAndInt64sUsingBlock:
7185    (void (NS_NOESCAPE ^)(int64_t key, int64_t value, BOOL *stop))block {
7186  BOOL stop = NO;
7187  NSDictionary *internal = _dictionary;
7188  NSEnumerator *keys = [internal keyEnumerator];
7189  NSNumber *aKey;
7190  while ((aKey = [keys nextObject])) {
7191    NSNumber *aValue = internal[aKey];
7192    block([aKey longLongValue], [aValue longLongValue], &stop);
7193    if (stop) {
7194      break;
7195    }
7196  }
7197}
7198
7199- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
7200  NSDictionary *internal = _dictionary;
7201  NSUInteger count = internal.count;
7202  if (count == 0) {
7203    return 0;
7204  }
7205
7206  GPBDataType valueDataType = GPBGetFieldDataType(field);
7207  GPBDataType keyDataType = field.mapKeyDataType;
7208  size_t result = 0;
7209  NSEnumerator *keys = [internal keyEnumerator];
7210  NSNumber *aKey;
7211  while ((aKey = [keys nextObject])) {
7212    NSNumber *aValue = internal[aKey];
7213    size_t msgSize = ComputeDictInt64FieldSize([aKey longLongValue], kMapKeyFieldNumber, keyDataType);
7214    msgSize += ComputeDictInt64FieldSize([aValue longLongValue], kMapValueFieldNumber, valueDataType);
7215    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
7216  }
7217  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
7218  result += tagSize * count;
7219  return result;
7220}
7221
7222- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
7223                         asField:(GPBFieldDescriptor *)field {
7224  GPBDataType valueDataType = GPBGetFieldDataType(field);
7225  GPBDataType keyDataType = field.mapKeyDataType;
7226  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
7227  NSDictionary *internal = _dictionary;
7228  NSEnumerator *keys = [internal keyEnumerator];
7229  NSNumber *aKey;
7230  while ((aKey = [keys nextObject])) {
7231    NSNumber *aValue = internal[aKey];
7232    [outputStream writeInt32NoTag:tag];
7233    // Write the size of the message.
7234    int64_t unwrappedKey = [aKey longLongValue];
7235    int64_t unwrappedValue = [aValue longLongValue];
7236    size_t msgSize = ComputeDictInt64FieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
7237    msgSize += ComputeDictInt64FieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
7238    [outputStream writeInt32NoTag:(int32_t)msgSize];
7239    // Write the fields.
7240    WriteDictInt64Field(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
7241    WriteDictInt64Field(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
7242  }
7243}
7244
7245- (void)setGPBGenericValue:(GPBGenericValue *)value
7246     forGPBGenericValueKey:(GPBGenericValue *)key {
7247  [_dictionary setObject:@(value->valueInt64) forKey:@(key->valueInt64)];
7248}
7249
7250- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
7251  [self enumerateKeysAndInt64sUsingBlock:^(int64_t key, int64_t value, __unused BOOL *stop) {
7252      block([NSString stringWithFormat:@"%lld", key], [NSString stringWithFormat:@"%lld", value]);
7253  }];
7254}
7255
7256- (BOOL)getInt64:(nullable int64_t *)value forKey:(int64_t)key {
7257  NSNumber *wrapped = [_dictionary objectForKey:@(key)];
7258  if (wrapped && value) {
7259    *value = [wrapped longLongValue];
7260  }
7261  return (wrapped != NULL);
7262}
7263
7264- (void)addEntriesFromDictionary:(GPBInt64Int64Dictionary *)otherDictionary {
7265  if (otherDictionary) {
7266    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
7267    if (_autocreator) {
7268      GPBAutocreatedDictionaryModified(_autocreator, self);
7269    }
7270  }
7271}
7272
7273- (void)setInt64:(int64_t)value forKey:(int64_t)key {
7274  [_dictionary setObject:@(value) forKey:@(key)];
7275  if (_autocreator) {
7276    GPBAutocreatedDictionaryModified(_autocreator, self);
7277  }
7278}
7279
7280- (void)removeInt64ForKey:(int64_t)aKey {
7281  [_dictionary removeObjectForKey:@(aKey)];
7282}
7283
7284- (void)removeAll {
7285  [_dictionary removeAllObjects];
7286}
7287
7288@end
7289
7290#pragma mark - Int64 -> Bool
7291
7292@implementation GPBInt64BoolDictionary {
7293 @package
7294  NSMutableDictionary *_dictionary;
7295}
7296
7297- (instancetype)init {
7298  return [self initWithBools:NULL forKeys:NULL count:0];
7299}
7300
7301- (instancetype)initWithBools:(const BOOL [])values
7302                      forKeys:(const int64_t [])keys
7303                        count:(NSUInteger)count {
7304  self = [super init];
7305  if (self) {
7306    _dictionary = [[NSMutableDictionary alloc] init];
7307    if (count && values && keys) {
7308      for (NSUInteger i = 0; i < count; ++i) {
7309        [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
7310      }
7311    }
7312  }
7313  return self;
7314}
7315
7316- (instancetype)initWithDictionary:(GPBInt64BoolDictionary *)dictionary {
7317  self = [self initWithBools:NULL forKeys:NULL count:0];
7318  if (self) {
7319    if (dictionary) {
7320      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
7321    }
7322  }
7323  return self;
7324}
7325
7326- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
7327  return [self initWithBools:NULL forKeys:NULL count:0];
7328}
7329
7330- (void)dealloc {
7331  NSAssert(!_autocreator,
7332           @"%@: Autocreator must be cleared before release, autocreator: %@",
7333           [self class], _autocreator);
7334  [_dictionary release];
7335  [super dealloc];
7336}
7337
7338- (instancetype)copyWithZone:(NSZone *)zone {
7339  return [[GPBInt64BoolDictionary allocWithZone:zone] initWithDictionary:self];
7340}
7341
7342- (BOOL)isEqual:(id)other {
7343  if (self == other) {
7344    return YES;
7345  }
7346  if (![other isKindOfClass:[GPBInt64BoolDictionary class]]) {
7347    return NO;
7348  }
7349  GPBInt64BoolDictionary *otherDictionary = other;
7350  return [_dictionary isEqual:otherDictionary->_dictionary];
7351}
7352
7353- (NSUInteger)hash {
7354  return _dictionary.count;
7355}
7356
7357- (NSString *)description {
7358  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
7359}
7360
7361- (NSUInteger)count {
7362  return _dictionary.count;
7363}
7364
7365- (void)enumerateKeysAndBoolsUsingBlock:
7366    (void (NS_NOESCAPE ^)(int64_t key, BOOL value, BOOL *stop))block {
7367  BOOL stop = NO;
7368  NSDictionary *internal = _dictionary;
7369  NSEnumerator *keys = [internal keyEnumerator];
7370  NSNumber *aKey;
7371  while ((aKey = [keys nextObject])) {
7372    NSNumber *aValue = internal[aKey];
7373    block([aKey longLongValue], [aValue boolValue], &stop);
7374    if (stop) {
7375      break;
7376    }
7377  }
7378}
7379
7380- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
7381  NSDictionary *internal = _dictionary;
7382  NSUInteger count = internal.count;
7383  if (count == 0) {
7384    return 0;
7385  }
7386
7387  GPBDataType valueDataType = GPBGetFieldDataType(field);
7388  GPBDataType keyDataType = field.mapKeyDataType;
7389  size_t result = 0;
7390  NSEnumerator *keys = [internal keyEnumerator];
7391  NSNumber *aKey;
7392  while ((aKey = [keys nextObject])) {
7393    NSNumber *aValue = internal[aKey];
7394    size_t msgSize = ComputeDictInt64FieldSize([aKey longLongValue], kMapKeyFieldNumber, keyDataType);
7395    msgSize += ComputeDictBoolFieldSize([aValue boolValue], kMapValueFieldNumber, valueDataType);
7396    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
7397  }
7398  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
7399  result += tagSize * count;
7400  return result;
7401}
7402
7403- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
7404                         asField:(GPBFieldDescriptor *)field {
7405  GPBDataType valueDataType = GPBGetFieldDataType(field);
7406  GPBDataType keyDataType = field.mapKeyDataType;
7407  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
7408  NSDictionary *internal = _dictionary;
7409  NSEnumerator *keys = [internal keyEnumerator];
7410  NSNumber *aKey;
7411  while ((aKey = [keys nextObject])) {
7412    NSNumber *aValue = internal[aKey];
7413    [outputStream writeInt32NoTag:tag];
7414    // Write the size of the message.
7415    int64_t unwrappedKey = [aKey longLongValue];
7416    BOOL unwrappedValue = [aValue boolValue];
7417    size_t msgSize = ComputeDictInt64FieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
7418    msgSize += ComputeDictBoolFieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
7419    [outputStream writeInt32NoTag:(int32_t)msgSize];
7420    // Write the fields.
7421    WriteDictInt64Field(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
7422    WriteDictBoolField(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
7423  }
7424}
7425
7426- (void)setGPBGenericValue:(GPBGenericValue *)value
7427     forGPBGenericValueKey:(GPBGenericValue *)key {
7428  [_dictionary setObject:@(value->valueBool) forKey:@(key->valueInt64)];
7429}
7430
7431- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
7432  [self enumerateKeysAndBoolsUsingBlock:^(int64_t key, BOOL value, __unused BOOL *stop) {
7433      block([NSString stringWithFormat:@"%lld", key], (value ? @"true" : @"false"));
7434  }];
7435}
7436
7437- (BOOL)getBool:(nullable BOOL *)value forKey:(int64_t)key {
7438  NSNumber *wrapped = [_dictionary objectForKey:@(key)];
7439  if (wrapped && value) {
7440    *value = [wrapped boolValue];
7441  }
7442  return (wrapped != NULL);
7443}
7444
7445- (void)addEntriesFromDictionary:(GPBInt64BoolDictionary *)otherDictionary {
7446  if (otherDictionary) {
7447    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
7448    if (_autocreator) {
7449      GPBAutocreatedDictionaryModified(_autocreator, self);
7450    }
7451  }
7452}
7453
7454- (void)setBool:(BOOL)value forKey:(int64_t)key {
7455  [_dictionary setObject:@(value) forKey:@(key)];
7456  if (_autocreator) {
7457    GPBAutocreatedDictionaryModified(_autocreator, self);
7458  }
7459}
7460
7461- (void)removeBoolForKey:(int64_t)aKey {
7462  [_dictionary removeObjectForKey:@(aKey)];
7463}
7464
7465- (void)removeAll {
7466  [_dictionary removeAllObjects];
7467}
7468
7469@end
7470
7471#pragma mark - Int64 -> Float
7472
7473@implementation GPBInt64FloatDictionary {
7474 @package
7475  NSMutableDictionary *_dictionary;
7476}
7477
7478- (instancetype)init {
7479  return [self initWithFloats:NULL forKeys:NULL count:0];
7480}
7481
7482- (instancetype)initWithFloats:(const float [])values
7483                       forKeys:(const int64_t [])keys
7484                         count:(NSUInteger)count {
7485  self = [super init];
7486  if (self) {
7487    _dictionary = [[NSMutableDictionary alloc] init];
7488    if (count && values && keys) {
7489      for (NSUInteger i = 0; i < count; ++i) {
7490        [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
7491      }
7492    }
7493  }
7494  return self;
7495}
7496
7497- (instancetype)initWithDictionary:(GPBInt64FloatDictionary *)dictionary {
7498  self = [self initWithFloats:NULL forKeys:NULL count:0];
7499  if (self) {
7500    if (dictionary) {
7501      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
7502    }
7503  }
7504  return self;
7505}
7506
7507- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
7508  return [self initWithFloats:NULL forKeys:NULL count:0];
7509}
7510
7511- (void)dealloc {
7512  NSAssert(!_autocreator,
7513           @"%@: Autocreator must be cleared before release, autocreator: %@",
7514           [self class], _autocreator);
7515  [_dictionary release];
7516  [super dealloc];
7517}
7518
7519- (instancetype)copyWithZone:(NSZone *)zone {
7520  return [[GPBInt64FloatDictionary allocWithZone:zone] initWithDictionary:self];
7521}
7522
7523- (BOOL)isEqual:(id)other {
7524  if (self == other) {
7525    return YES;
7526  }
7527  if (![other isKindOfClass:[GPBInt64FloatDictionary class]]) {
7528    return NO;
7529  }
7530  GPBInt64FloatDictionary *otherDictionary = other;
7531  return [_dictionary isEqual:otherDictionary->_dictionary];
7532}
7533
7534- (NSUInteger)hash {
7535  return _dictionary.count;
7536}
7537
7538- (NSString *)description {
7539  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
7540}
7541
7542- (NSUInteger)count {
7543  return _dictionary.count;
7544}
7545
7546- (void)enumerateKeysAndFloatsUsingBlock:
7547    (void (NS_NOESCAPE ^)(int64_t key, float value, BOOL *stop))block {
7548  BOOL stop = NO;
7549  NSDictionary *internal = _dictionary;
7550  NSEnumerator *keys = [internal keyEnumerator];
7551  NSNumber *aKey;
7552  while ((aKey = [keys nextObject])) {
7553    NSNumber *aValue = internal[aKey];
7554    block([aKey longLongValue], [aValue floatValue], &stop);
7555    if (stop) {
7556      break;
7557    }
7558  }
7559}
7560
7561- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
7562  NSDictionary *internal = _dictionary;
7563  NSUInteger count = internal.count;
7564  if (count == 0) {
7565    return 0;
7566  }
7567
7568  GPBDataType valueDataType = GPBGetFieldDataType(field);
7569  GPBDataType keyDataType = field.mapKeyDataType;
7570  size_t result = 0;
7571  NSEnumerator *keys = [internal keyEnumerator];
7572  NSNumber *aKey;
7573  while ((aKey = [keys nextObject])) {
7574    NSNumber *aValue = internal[aKey];
7575    size_t msgSize = ComputeDictInt64FieldSize([aKey longLongValue], kMapKeyFieldNumber, keyDataType);
7576    msgSize += ComputeDictFloatFieldSize([aValue floatValue], kMapValueFieldNumber, valueDataType);
7577    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
7578  }
7579  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
7580  result += tagSize * count;
7581  return result;
7582}
7583
7584- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
7585                         asField:(GPBFieldDescriptor *)field {
7586  GPBDataType valueDataType = GPBGetFieldDataType(field);
7587  GPBDataType keyDataType = field.mapKeyDataType;
7588  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
7589  NSDictionary *internal = _dictionary;
7590  NSEnumerator *keys = [internal keyEnumerator];
7591  NSNumber *aKey;
7592  while ((aKey = [keys nextObject])) {
7593    NSNumber *aValue = internal[aKey];
7594    [outputStream writeInt32NoTag:tag];
7595    // Write the size of the message.
7596    int64_t unwrappedKey = [aKey longLongValue];
7597    float unwrappedValue = [aValue floatValue];
7598    size_t msgSize = ComputeDictInt64FieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
7599    msgSize += ComputeDictFloatFieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
7600    [outputStream writeInt32NoTag:(int32_t)msgSize];
7601    // Write the fields.
7602    WriteDictInt64Field(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
7603    WriteDictFloatField(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
7604  }
7605}
7606
7607- (void)setGPBGenericValue:(GPBGenericValue *)value
7608     forGPBGenericValueKey:(GPBGenericValue *)key {
7609  [_dictionary setObject:@(value->valueFloat) forKey:@(key->valueInt64)];
7610}
7611
7612- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
7613  [self enumerateKeysAndFloatsUsingBlock:^(int64_t key, float value, __unused BOOL *stop) {
7614      block([NSString stringWithFormat:@"%lld", key], [NSString stringWithFormat:@"%.*g", FLT_DIG, value]);
7615  }];
7616}
7617
7618- (BOOL)getFloat:(nullable float *)value forKey:(int64_t)key {
7619  NSNumber *wrapped = [_dictionary objectForKey:@(key)];
7620  if (wrapped && value) {
7621    *value = [wrapped floatValue];
7622  }
7623  return (wrapped != NULL);
7624}
7625
7626- (void)addEntriesFromDictionary:(GPBInt64FloatDictionary *)otherDictionary {
7627  if (otherDictionary) {
7628    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
7629    if (_autocreator) {
7630      GPBAutocreatedDictionaryModified(_autocreator, self);
7631    }
7632  }
7633}
7634
7635- (void)setFloat:(float)value forKey:(int64_t)key {
7636  [_dictionary setObject:@(value) forKey:@(key)];
7637  if (_autocreator) {
7638    GPBAutocreatedDictionaryModified(_autocreator, self);
7639  }
7640}
7641
7642- (void)removeFloatForKey:(int64_t)aKey {
7643  [_dictionary removeObjectForKey:@(aKey)];
7644}
7645
7646- (void)removeAll {
7647  [_dictionary removeAllObjects];
7648}
7649
7650@end
7651
7652#pragma mark - Int64 -> Double
7653
7654@implementation GPBInt64DoubleDictionary {
7655 @package
7656  NSMutableDictionary *_dictionary;
7657}
7658
7659- (instancetype)init {
7660  return [self initWithDoubles:NULL forKeys:NULL count:0];
7661}
7662
7663- (instancetype)initWithDoubles:(const double [])values
7664                        forKeys:(const int64_t [])keys
7665                          count:(NSUInteger)count {
7666  self = [super init];
7667  if (self) {
7668    _dictionary = [[NSMutableDictionary alloc] init];
7669    if (count && values && keys) {
7670      for (NSUInteger i = 0; i < count; ++i) {
7671        [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
7672      }
7673    }
7674  }
7675  return self;
7676}
7677
7678- (instancetype)initWithDictionary:(GPBInt64DoubleDictionary *)dictionary {
7679  self = [self initWithDoubles:NULL forKeys:NULL count:0];
7680  if (self) {
7681    if (dictionary) {
7682      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
7683    }
7684  }
7685  return self;
7686}
7687
7688- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
7689  return [self initWithDoubles:NULL forKeys:NULL count:0];
7690}
7691
7692- (void)dealloc {
7693  NSAssert(!_autocreator,
7694           @"%@: Autocreator must be cleared before release, autocreator: %@",
7695           [self class], _autocreator);
7696  [_dictionary release];
7697  [super dealloc];
7698}
7699
7700- (instancetype)copyWithZone:(NSZone *)zone {
7701  return [[GPBInt64DoubleDictionary allocWithZone:zone] initWithDictionary:self];
7702}
7703
7704- (BOOL)isEqual:(id)other {
7705  if (self == other) {
7706    return YES;
7707  }
7708  if (![other isKindOfClass:[GPBInt64DoubleDictionary class]]) {
7709    return NO;
7710  }
7711  GPBInt64DoubleDictionary *otherDictionary = other;
7712  return [_dictionary isEqual:otherDictionary->_dictionary];
7713}
7714
7715- (NSUInteger)hash {
7716  return _dictionary.count;
7717}
7718
7719- (NSString *)description {
7720  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
7721}
7722
7723- (NSUInteger)count {
7724  return _dictionary.count;
7725}
7726
7727- (void)enumerateKeysAndDoublesUsingBlock:
7728    (void (NS_NOESCAPE ^)(int64_t key, double value, BOOL *stop))block {
7729  BOOL stop = NO;
7730  NSDictionary *internal = _dictionary;
7731  NSEnumerator *keys = [internal keyEnumerator];
7732  NSNumber *aKey;
7733  while ((aKey = [keys nextObject])) {
7734    NSNumber *aValue = internal[aKey];
7735    block([aKey longLongValue], [aValue doubleValue], &stop);
7736    if (stop) {
7737      break;
7738    }
7739  }
7740}
7741
7742- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
7743  NSDictionary *internal = _dictionary;
7744  NSUInteger count = internal.count;
7745  if (count == 0) {
7746    return 0;
7747  }
7748
7749  GPBDataType valueDataType = GPBGetFieldDataType(field);
7750  GPBDataType keyDataType = field.mapKeyDataType;
7751  size_t result = 0;
7752  NSEnumerator *keys = [internal keyEnumerator];
7753  NSNumber *aKey;
7754  while ((aKey = [keys nextObject])) {
7755    NSNumber *aValue = internal[aKey];
7756    size_t msgSize = ComputeDictInt64FieldSize([aKey longLongValue], kMapKeyFieldNumber, keyDataType);
7757    msgSize += ComputeDictDoubleFieldSize([aValue doubleValue], kMapValueFieldNumber, valueDataType);
7758    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
7759  }
7760  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
7761  result += tagSize * count;
7762  return result;
7763}
7764
7765- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
7766                         asField:(GPBFieldDescriptor *)field {
7767  GPBDataType valueDataType = GPBGetFieldDataType(field);
7768  GPBDataType keyDataType = field.mapKeyDataType;
7769  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
7770  NSDictionary *internal = _dictionary;
7771  NSEnumerator *keys = [internal keyEnumerator];
7772  NSNumber *aKey;
7773  while ((aKey = [keys nextObject])) {
7774    NSNumber *aValue = internal[aKey];
7775    [outputStream writeInt32NoTag:tag];
7776    // Write the size of the message.
7777    int64_t unwrappedKey = [aKey longLongValue];
7778    double unwrappedValue = [aValue doubleValue];
7779    size_t msgSize = ComputeDictInt64FieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
7780    msgSize += ComputeDictDoubleFieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
7781    [outputStream writeInt32NoTag:(int32_t)msgSize];
7782    // Write the fields.
7783    WriteDictInt64Field(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
7784    WriteDictDoubleField(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
7785  }
7786}
7787
7788- (void)setGPBGenericValue:(GPBGenericValue *)value
7789     forGPBGenericValueKey:(GPBGenericValue *)key {
7790  [_dictionary setObject:@(value->valueDouble) forKey:@(key->valueInt64)];
7791}
7792
7793- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
7794  [self enumerateKeysAndDoublesUsingBlock:^(int64_t key, double value, __unused BOOL *stop) {
7795      block([NSString stringWithFormat:@"%lld", key], [NSString stringWithFormat:@"%.*lg", DBL_DIG, value]);
7796  }];
7797}
7798
7799- (BOOL)getDouble:(nullable double *)value forKey:(int64_t)key {
7800  NSNumber *wrapped = [_dictionary objectForKey:@(key)];
7801  if (wrapped && value) {
7802    *value = [wrapped doubleValue];
7803  }
7804  return (wrapped != NULL);
7805}
7806
7807- (void)addEntriesFromDictionary:(GPBInt64DoubleDictionary *)otherDictionary {
7808  if (otherDictionary) {
7809    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
7810    if (_autocreator) {
7811      GPBAutocreatedDictionaryModified(_autocreator, self);
7812    }
7813  }
7814}
7815
7816- (void)setDouble:(double)value forKey:(int64_t)key {
7817  [_dictionary setObject:@(value) forKey:@(key)];
7818  if (_autocreator) {
7819    GPBAutocreatedDictionaryModified(_autocreator, self);
7820  }
7821}
7822
7823- (void)removeDoubleForKey:(int64_t)aKey {
7824  [_dictionary removeObjectForKey:@(aKey)];
7825}
7826
7827- (void)removeAll {
7828  [_dictionary removeAllObjects];
7829}
7830
7831@end
7832
7833#pragma mark - Int64 -> Enum
7834
7835@implementation GPBInt64EnumDictionary {
7836 @package
7837  NSMutableDictionary *_dictionary;
7838  GPBEnumValidationFunc _validationFunc;
7839}
7840
7841@synthesize validationFunc = _validationFunc;
7842
7843- (instancetype)init {
7844  return [self initWithValidationFunction:NULL rawValues:NULL forKeys:NULL count:0];
7845}
7846
7847- (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func {
7848  return [self initWithValidationFunction:func rawValues:NULL forKeys:NULL count:0];
7849}
7850
7851- (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func
7852                                 rawValues:(const int32_t [])rawValues
7853                                   forKeys:(const int64_t [])keys
7854                                     count:(NSUInteger)count {
7855  self = [super init];
7856  if (self) {
7857    _dictionary = [[NSMutableDictionary alloc] init];
7858    _validationFunc = (func != NULL ? func : DictDefault_IsValidValue);
7859    if (count && rawValues && keys) {
7860      for (NSUInteger i = 0; i < count; ++i) {
7861        [_dictionary setObject:@(rawValues[i]) forKey:@(keys[i])];
7862      }
7863    }
7864  }
7865  return self;
7866}
7867
7868- (instancetype)initWithDictionary:(GPBInt64EnumDictionary *)dictionary {
7869  self = [self initWithValidationFunction:dictionary.validationFunc
7870                                rawValues:NULL
7871                                  forKeys:NULL
7872                                    count:0];
7873  if (self) {
7874    if (dictionary) {
7875      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
7876    }
7877  }
7878  return self;
7879}
7880
7881- (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func
7882                                  capacity:(__unused NSUInteger)numItems {
7883  return [self initWithValidationFunction:func rawValues:NULL forKeys:NULL count:0];
7884}
7885
7886- (void)dealloc {
7887  NSAssert(!_autocreator,
7888           @"%@: Autocreator must be cleared before release, autocreator: %@",
7889           [self class], _autocreator);
7890  [_dictionary release];
7891  [super dealloc];
7892}
7893
7894- (instancetype)copyWithZone:(NSZone *)zone {
7895  return [[GPBInt64EnumDictionary allocWithZone:zone] initWithDictionary:self];
7896}
7897
7898- (BOOL)isEqual:(id)other {
7899  if (self == other) {
7900    return YES;
7901  }
7902  if (![other isKindOfClass:[GPBInt64EnumDictionary class]]) {
7903    return NO;
7904  }
7905  GPBInt64EnumDictionary *otherDictionary = other;
7906  return [_dictionary isEqual:otherDictionary->_dictionary];
7907}
7908
7909- (NSUInteger)hash {
7910  return _dictionary.count;
7911}
7912
7913- (NSString *)description {
7914  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
7915}
7916
7917- (NSUInteger)count {
7918  return _dictionary.count;
7919}
7920
7921- (void)enumerateKeysAndRawValuesUsingBlock:
7922    (void (NS_NOESCAPE ^)(int64_t key, int32_t value, BOOL *stop))block {
7923  BOOL stop = NO;
7924  NSDictionary *internal = _dictionary;
7925  NSEnumerator *keys = [internal keyEnumerator];
7926  NSNumber *aKey;
7927  while ((aKey = [keys nextObject])) {
7928    NSNumber *aValue = internal[aKey];
7929    block([aKey longLongValue], [aValue intValue], &stop);
7930    if (stop) {
7931      break;
7932    }
7933  }
7934}
7935
7936- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
7937  NSDictionary *internal = _dictionary;
7938  NSUInteger count = internal.count;
7939  if (count == 0) {
7940    return 0;
7941  }
7942
7943  GPBDataType valueDataType = GPBGetFieldDataType(field);
7944  GPBDataType keyDataType = field.mapKeyDataType;
7945  size_t result = 0;
7946  NSEnumerator *keys = [internal keyEnumerator];
7947  NSNumber *aKey;
7948  while ((aKey = [keys nextObject])) {
7949    NSNumber *aValue = internal[aKey];
7950    size_t msgSize = ComputeDictInt64FieldSize([aKey longLongValue], kMapKeyFieldNumber, keyDataType);
7951    msgSize += ComputeDictEnumFieldSize([aValue intValue], kMapValueFieldNumber, valueDataType);
7952    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
7953  }
7954  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
7955  result += tagSize * count;
7956  return result;
7957}
7958
7959- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
7960                         asField:(GPBFieldDescriptor *)field {
7961  GPBDataType valueDataType = GPBGetFieldDataType(field);
7962  GPBDataType keyDataType = field.mapKeyDataType;
7963  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
7964  NSDictionary *internal = _dictionary;
7965  NSEnumerator *keys = [internal keyEnumerator];
7966  NSNumber *aKey;
7967  while ((aKey = [keys nextObject])) {
7968    NSNumber *aValue = internal[aKey];
7969    [outputStream writeInt32NoTag:tag];
7970    // Write the size of the message.
7971    int64_t unwrappedKey = [aKey longLongValue];
7972    int32_t unwrappedValue = [aValue intValue];
7973    size_t msgSize = ComputeDictInt64FieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
7974    msgSize += ComputeDictEnumFieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
7975    [outputStream writeInt32NoTag:(int32_t)msgSize];
7976    // Write the fields.
7977    WriteDictInt64Field(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
7978    WriteDictEnumField(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
7979  }
7980}
7981
7982- (NSData *)serializedDataForUnknownValue:(int32_t)value
7983                                   forKey:(GPBGenericValue *)key
7984                              keyDataType:(GPBDataType)keyDataType {
7985  size_t msgSize = ComputeDictInt64FieldSize(key->valueInt64, kMapKeyFieldNumber, keyDataType);
7986  msgSize += ComputeDictEnumFieldSize(value, kMapValueFieldNumber, GPBDataTypeEnum);
7987  NSMutableData *data = [NSMutableData dataWithLength:msgSize];
7988  GPBCodedOutputStream *outputStream = [[GPBCodedOutputStream alloc] initWithData:data];
7989  WriteDictInt64Field(outputStream, key->valueInt64, kMapKeyFieldNumber, keyDataType);
7990  WriteDictEnumField(outputStream, value, kMapValueFieldNumber, GPBDataTypeEnum);
7991  [outputStream flush];
7992  [outputStream release];
7993  return data;
7994}
7995- (void)setGPBGenericValue:(GPBGenericValue *)value
7996     forGPBGenericValueKey:(GPBGenericValue *)key {
7997  [_dictionary setObject:@(value->valueEnum) forKey:@(key->valueInt64)];
7998}
7999
8000- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
8001  [self enumerateKeysAndRawValuesUsingBlock:^(int64_t key, int32_t value, __unused BOOL *stop) {
8002      block([NSString stringWithFormat:@"%lld", key], @(value));
8003  }];
8004}
8005
8006- (BOOL)getEnum:(int32_t *)value forKey:(int64_t)key {
8007  NSNumber *wrapped = [_dictionary objectForKey:@(key)];
8008  if (wrapped && value) {
8009    int32_t result = [wrapped intValue];
8010    if (!_validationFunc(result)) {
8011      result = kGPBUnrecognizedEnumeratorValue;
8012    }
8013    *value = result;
8014  }
8015  return (wrapped != NULL);
8016}
8017
8018- (BOOL)getRawValue:(int32_t *)rawValue forKey:(int64_t)key {
8019  NSNumber *wrapped = [_dictionary objectForKey:@(key)];
8020  if (wrapped && rawValue) {
8021    *rawValue = [wrapped intValue];
8022  }
8023  return (wrapped != NULL);
8024}
8025
8026- (void)enumerateKeysAndEnumsUsingBlock:
8027    (void (NS_NOESCAPE ^)(int64_t key, int32_t value, BOOL *stop))block {
8028  GPBEnumValidationFunc func = _validationFunc;
8029  BOOL stop = NO;
8030  NSEnumerator *keys = [_dictionary keyEnumerator];
8031  NSNumber *aKey;
8032  while ((aKey = [keys nextObject])) {
8033    NSNumber *aValue = _dictionary[aKey];
8034      int32_t unwrapped = [aValue intValue];
8035      if (!func(unwrapped)) {
8036        unwrapped = kGPBUnrecognizedEnumeratorValue;
8037      }
8038    block([aKey longLongValue], unwrapped, &stop);
8039    if (stop) {
8040      break;
8041    }
8042  }
8043}
8044
8045- (void)addRawEntriesFromDictionary:(GPBInt64EnumDictionary *)otherDictionary {
8046  if (otherDictionary) {
8047    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
8048    if (_autocreator) {
8049      GPBAutocreatedDictionaryModified(_autocreator, self);
8050    }
8051  }
8052}
8053
8054- (void)setRawValue:(int32_t)value forKey:(int64_t)key {
8055  [_dictionary setObject:@(value) forKey:@(key)];
8056  if (_autocreator) {
8057    GPBAutocreatedDictionaryModified(_autocreator, self);
8058  }
8059}
8060
8061- (void)removeEnumForKey:(int64_t)aKey {
8062  [_dictionary removeObjectForKey:@(aKey)];
8063}
8064
8065- (void)removeAll {
8066  [_dictionary removeAllObjects];
8067}
8068
8069- (void)setEnum:(int32_t)value forKey:(int64_t)key {
8070  if (!_validationFunc(value)) {
8071    [NSException raise:NSInvalidArgumentException
8072                format:@"GPBInt64EnumDictionary: Attempt to set an unknown enum value (%d)",
8073                       value];
8074  }
8075
8076  [_dictionary setObject:@(value) forKey:@(key)];
8077  if (_autocreator) {
8078    GPBAutocreatedDictionaryModified(_autocreator, self);
8079  }
8080}
8081
8082@end
8083
8084#pragma mark - Int64 -> Object
8085
8086@implementation GPBInt64ObjectDictionary {
8087 @package
8088  NSMutableDictionary *_dictionary;
8089}
8090
8091- (instancetype)init {
8092  return [self initWithObjects:NULL forKeys:NULL count:0];
8093}
8094
8095- (instancetype)initWithObjects:(const id [])objects
8096                        forKeys:(const int64_t [])keys
8097                          count:(NSUInteger)count {
8098  self = [super init];
8099  if (self) {
8100    _dictionary = [[NSMutableDictionary alloc] init];
8101    if (count && objects && keys) {
8102      for (NSUInteger i = 0; i < count; ++i) {
8103        if (!objects[i]) {
8104          [NSException raise:NSInvalidArgumentException
8105                      format:@"Attempting to add nil object to a Dictionary"];
8106        }
8107        [_dictionary setObject:objects[i] forKey:@(keys[i])];
8108      }
8109    }
8110  }
8111  return self;
8112}
8113
8114- (instancetype)initWithDictionary:(GPBInt64ObjectDictionary *)dictionary {
8115  self = [self initWithObjects:NULL forKeys:NULL count:0];
8116  if (self) {
8117    if (dictionary) {
8118      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
8119    }
8120  }
8121  return self;
8122}
8123
8124- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
8125  return [self initWithObjects:NULL forKeys:NULL count:0];
8126}
8127
8128- (void)dealloc {
8129  NSAssert(!_autocreator,
8130           @"%@: Autocreator must be cleared before release, autocreator: %@",
8131           [self class], _autocreator);
8132  [_dictionary release];
8133  [super dealloc];
8134}
8135
8136- (instancetype)copyWithZone:(NSZone *)zone {
8137  return [[GPBInt64ObjectDictionary allocWithZone:zone] initWithDictionary:self];
8138}
8139
8140- (BOOL)isEqual:(id)other {
8141  if (self == other) {
8142    return YES;
8143  }
8144  if (![other isKindOfClass:[GPBInt64ObjectDictionary class]]) {
8145    return NO;
8146  }
8147  GPBInt64ObjectDictionary *otherDictionary = other;
8148  return [_dictionary isEqual:otherDictionary->_dictionary];
8149}
8150
8151- (NSUInteger)hash {
8152  return _dictionary.count;
8153}
8154
8155- (NSString *)description {
8156  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
8157}
8158
8159- (NSUInteger)count {
8160  return _dictionary.count;
8161}
8162
8163- (void)enumerateKeysAndObjectsUsingBlock:
8164    (void (NS_NOESCAPE ^)(int64_t key, id object, BOOL *stop))block {
8165  BOOL stop = NO;
8166  NSDictionary *internal = _dictionary;
8167  NSEnumerator *keys = [internal keyEnumerator];
8168  NSNumber *aKey;
8169  while ((aKey = [keys nextObject])) {
8170    id aObject = internal[aKey];
8171    block([aKey longLongValue], aObject, &stop);
8172    if (stop) {
8173      break;
8174    }
8175  }
8176}
8177
8178- (BOOL)isInitialized {
8179  for (GPBMessage *msg in [_dictionary objectEnumerator]) {
8180    if (!msg.initialized) {
8181      return NO;
8182    }
8183  }
8184  return YES;
8185}
8186
8187- (instancetype)deepCopyWithZone:(NSZone *)zone {
8188  GPBInt64ObjectDictionary *newDict =
8189      [[GPBInt64ObjectDictionary alloc] init];
8190  NSEnumerator *keys = [_dictionary keyEnumerator];
8191  id aKey;
8192  NSMutableDictionary *internalDict = newDict->_dictionary;
8193  while ((aKey = [keys nextObject])) {
8194    GPBMessage *msg = _dictionary[aKey];
8195    GPBMessage *copiedMsg = [msg copyWithZone:zone];
8196    [internalDict setObject:copiedMsg forKey:aKey];
8197    [copiedMsg release];
8198  }
8199  return newDict;
8200}
8201
8202- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
8203  NSDictionary *internal = _dictionary;
8204  NSUInteger count = internal.count;
8205  if (count == 0) {
8206    return 0;
8207  }
8208
8209  GPBDataType valueDataType = GPBGetFieldDataType(field);
8210  GPBDataType keyDataType = field.mapKeyDataType;
8211  size_t result = 0;
8212  NSEnumerator *keys = [internal keyEnumerator];
8213  NSNumber *aKey;
8214  while ((aKey = [keys nextObject])) {
8215    id aObject = internal[aKey];
8216    size_t msgSize = ComputeDictInt64FieldSize([aKey longLongValue], kMapKeyFieldNumber, keyDataType);
8217    msgSize += ComputeDictObjectFieldSize(aObject, kMapValueFieldNumber, valueDataType);
8218    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
8219  }
8220  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
8221  result += tagSize * count;
8222  return result;
8223}
8224
8225- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
8226                         asField:(GPBFieldDescriptor *)field {
8227  GPBDataType valueDataType = GPBGetFieldDataType(field);
8228  GPBDataType keyDataType = field.mapKeyDataType;
8229  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
8230  NSDictionary *internal = _dictionary;
8231  NSEnumerator *keys = [internal keyEnumerator];
8232  NSNumber *aKey;
8233  while ((aKey = [keys nextObject])) {
8234    id aObject = internal[aKey];
8235    [outputStream writeInt32NoTag:tag];
8236    // Write the size of the message.
8237    int64_t unwrappedKey = [aKey longLongValue];
8238    id unwrappedValue = aObject;
8239    size_t msgSize = ComputeDictInt64FieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
8240    msgSize += ComputeDictObjectFieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
8241    [outputStream writeInt32NoTag:(int32_t)msgSize];
8242    // Write the fields.
8243    WriteDictInt64Field(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
8244    WriteDictObjectField(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
8245  }
8246}
8247
8248- (void)setGPBGenericValue:(GPBGenericValue *)value
8249     forGPBGenericValueKey:(GPBGenericValue *)key {
8250  [_dictionary setObject:value->valueString forKey:@(key->valueInt64)];
8251}
8252
8253- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
8254  [self enumerateKeysAndObjectsUsingBlock:^(int64_t key, id object, __unused BOOL *stop) {
8255      block([NSString stringWithFormat:@"%lld", key], object);
8256  }];
8257}
8258
8259- (id)objectForKey:(int64_t)key {
8260  id result = [_dictionary objectForKey:@(key)];
8261  return result;
8262}
8263
8264- (void)addEntriesFromDictionary:(GPBInt64ObjectDictionary *)otherDictionary {
8265  if (otherDictionary) {
8266    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
8267    if (_autocreator) {
8268      GPBAutocreatedDictionaryModified(_autocreator, self);
8269    }
8270  }
8271}
8272
8273- (void)setObject:(id)object forKey:(int64_t)key {
8274  if (!object) {
8275    [NSException raise:NSInvalidArgumentException
8276                format:@"Attempting to add nil object to a Dictionary"];
8277  }
8278  [_dictionary setObject:object forKey:@(key)];
8279  if (_autocreator) {
8280    GPBAutocreatedDictionaryModified(_autocreator, self);
8281  }
8282}
8283
8284- (void)removeObjectForKey:(int64_t)aKey {
8285  [_dictionary removeObjectForKey:@(aKey)];
8286}
8287
8288- (void)removeAll {
8289  [_dictionary removeAllObjects];
8290}
8291
8292@end
8293
8294//%PDDM-EXPAND DICTIONARY_POD_IMPL_FOR_KEY(String, NSString, *, OBJECT)
8295// This block of code is generated, do not edit it directly.
8296
8297#pragma mark - String -> UInt32
8298
8299@implementation GPBStringUInt32Dictionary {
8300 @package
8301  NSMutableDictionary *_dictionary;
8302}
8303
8304- (instancetype)init {
8305  return [self initWithUInt32s:NULL forKeys:NULL count:0];
8306}
8307
8308- (instancetype)initWithUInt32s:(const uint32_t [])values
8309                        forKeys:(const NSString * [])keys
8310                          count:(NSUInteger)count {
8311  self = [super init];
8312  if (self) {
8313    _dictionary = [[NSMutableDictionary alloc] init];
8314    if (count && values && keys) {
8315      for (NSUInteger i = 0; i < count; ++i) {
8316        if (!keys[i]) {
8317          [NSException raise:NSInvalidArgumentException
8318                      format:@"Attempting to add nil key to a Dictionary"];
8319        }
8320        [_dictionary setObject:@(values[i]) forKey:keys[i]];
8321      }
8322    }
8323  }
8324  return self;
8325}
8326
8327- (instancetype)initWithDictionary:(GPBStringUInt32Dictionary *)dictionary {
8328  self = [self initWithUInt32s:NULL forKeys:NULL count:0];
8329  if (self) {
8330    if (dictionary) {
8331      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
8332    }
8333  }
8334  return self;
8335}
8336
8337- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
8338  return [self initWithUInt32s:NULL forKeys:NULL count:0];
8339}
8340
8341- (void)dealloc {
8342  NSAssert(!_autocreator,
8343           @"%@: Autocreator must be cleared before release, autocreator: %@",
8344           [self class], _autocreator);
8345  [_dictionary release];
8346  [super dealloc];
8347}
8348
8349- (instancetype)copyWithZone:(NSZone *)zone {
8350  return [[GPBStringUInt32Dictionary allocWithZone:zone] initWithDictionary:self];
8351}
8352
8353- (BOOL)isEqual:(id)other {
8354  if (self == other) {
8355    return YES;
8356  }
8357  if (![other isKindOfClass:[GPBStringUInt32Dictionary class]]) {
8358    return NO;
8359  }
8360  GPBStringUInt32Dictionary *otherDictionary = other;
8361  return [_dictionary isEqual:otherDictionary->_dictionary];
8362}
8363
8364- (NSUInteger)hash {
8365  return _dictionary.count;
8366}
8367
8368- (NSString *)description {
8369  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
8370}
8371
8372- (NSUInteger)count {
8373  return _dictionary.count;
8374}
8375
8376- (void)enumerateKeysAndUInt32sUsingBlock:
8377    (void (NS_NOESCAPE ^)(NSString *key, uint32_t value, BOOL *stop))block {
8378  BOOL stop = NO;
8379  NSDictionary *internal = _dictionary;
8380  NSEnumerator *keys = [internal keyEnumerator];
8381  NSString *aKey;
8382  while ((aKey = [keys nextObject])) {
8383    NSNumber *aValue = internal[aKey];
8384    block(aKey, [aValue unsignedIntValue], &stop);
8385    if (stop) {
8386      break;
8387    }
8388  }
8389}
8390
8391- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
8392  NSDictionary *internal = _dictionary;
8393  NSUInteger count = internal.count;
8394  if (count == 0) {
8395    return 0;
8396  }
8397
8398  GPBDataType valueDataType = GPBGetFieldDataType(field);
8399  GPBDataType keyDataType = field.mapKeyDataType;
8400  size_t result = 0;
8401  NSEnumerator *keys = [internal keyEnumerator];
8402  NSString *aKey;
8403  while ((aKey = [keys nextObject])) {
8404    NSNumber *aValue = internal[aKey];
8405    size_t msgSize = ComputeDictStringFieldSize(aKey, kMapKeyFieldNumber, keyDataType);
8406    msgSize += ComputeDictUInt32FieldSize([aValue unsignedIntValue], kMapValueFieldNumber, valueDataType);
8407    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
8408  }
8409  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
8410  result += tagSize * count;
8411  return result;
8412}
8413
8414- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
8415                         asField:(GPBFieldDescriptor *)field {
8416  GPBDataType valueDataType = GPBGetFieldDataType(field);
8417  GPBDataType keyDataType = field.mapKeyDataType;
8418  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
8419  NSDictionary *internal = _dictionary;
8420  NSEnumerator *keys = [internal keyEnumerator];
8421  NSString *aKey;
8422  while ((aKey = [keys nextObject])) {
8423    NSNumber *aValue = internal[aKey];
8424    [outputStream writeInt32NoTag:tag];
8425    // Write the size of the message.
8426    NSString *unwrappedKey = aKey;
8427    uint32_t unwrappedValue = [aValue unsignedIntValue];
8428    size_t msgSize = ComputeDictStringFieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
8429    msgSize += ComputeDictUInt32FieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
8430    [outputStream writeInt32NoTag:(int32_t)msgSize];
8431    // Write the fields.
8432    WriteDictStringField(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
8433    WriteDictUInt32Field(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
8434  }
8435}
8436
8437- (void)setGPBGenericValue:(GPBGenericValue *)value
8438     forGPBGenericValueKey:(GPBGenericValue *)key {
8439  [_dictionary setObject:@(value->valueUInt32) forKey:key->valueString];
8440}
8441
8442- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
8443  [self enumerateKeysAndUInt32sUsingBlock:^(NSString *key, uint32_t value, __unused BOOL *stop) {
8444      block(key, [NSString stringWithFormat:@"%u", value]);
8445  }];
8446}
8447
8448- (BOOL)getUInt32:(nullable uint32_t *)value forKey:(NSString *)key {
8449  NSNumber *wrapped = [_dictionary objectForKey:key];
8450  if (wrapped && value) {
8451    *value = [wrapped unsignedIntValue];
8452  }
8453  return (wrapped != NULL);
8454}
8455
8456- (void)addEntriesFromDictionary:(GPBStringUInt32Dictionary *)otherDictionary {
8457  if (otherDictionary) {
8458    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
8459    if (_autocreator) {
8460      GPBAutocreatedDictionaryModified(_autocreator, self);
8461    }
8462  }
8463}
8464
8465- (void)setUInt32:(uint32_t)value forKey:(NSString *)key {
8466  if (!key) {
8467    [NSException raise:NSInvalidArgumentException
8468                format:@"Attempting to add nil key to a Dictionary"];
8469  }
8470  [_dictionary setObject:@(value) forKey:key];
8471  if (_autocreator) {
8472    GPBAutocreatedDictionaryModified(_autocreator, self);
8473  }
8474}
8475
8476- (void)removeUInt32ForKey:(NSString *)aKey {
8477  [_dictionary removeObjectForKey:aKey];
8478}
8479
8480- (void)removeAll {
8481  [_dictionary removeAllObjects];
8482}
8483
8484@end
8485
8486#pragma mark - String -> Int32
8487
8488@implementation GPBStringInt32Dictionary {
8489 @package
8490  NSMutableDictionary *_dictionary;
8491}
8492
8493- (instancetype)init {
8494  return [self initWithInt32s:NULL forKeys:NULL count:0];
8495}
8496
8497- (instancetype)initWithInt32s:(const int32_t [])values
8498                       forKeys:(const NSString * [])keys
8499                         count:(NSUInteger)count {
8500  self = [super init];
8501  if (self) {
8502    _dictionary = [[NSMutableDictionary alloc] init];
8503    if (count && values && keys) {
8504      for (NSUInteger i = 0; i < count; ++i) {
8505        if (!keys[i]) {
8506          [NSException raise:NSInvalidArgumentException
8507                      format:@"Attempting to add nil key to a Dictionary"];
8508        }
8509        [_dictionary setObject:@(values[i]) forKey:keys[i]];
8510      }
8511    }
8512  }
8513  return self;
8514}
8515
8516- (instancetype)initWithDictionary:(GPBStringInt32Dictionary *)dictionary {
8517  self = [self initWithInt32s:NULL forKeys:NULL count:0];
8518  if (self) {
8519    if (dictionary) {
8520      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
8521    }
8522  }
8523  return self;
8524}
8525
8526- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
8527  return [self initWithInt32s:NULL forKeys:NULL count:0];
8528}
8529
8530- (void)dealloc {
8531  NSAssert(!_autocreator,
8532           @"%@: Autocreator must be cleared before release, autocreator: %@",
8533           [self class], _autocreator);
8534  [_dictionary release];
8535  [super dealloc];
8536}
8537
8538- (instancetype)copyWithZone:(NSZone *)zone {
8539  return [[GPBStringInt32Dictionary allocWithZone:zone] initWithDictionary:self];
8540}
8541
8542- (BOOL)isEqual:(id)other {
8543  if (self == other) {
8544    return YES;
8545  }
8546  if (![other isKindOfClass:[GPBStringInt32Dictionary class]]) {
8547    return NO;
8548  }
8549  GPBStringInt32Dictionary *otherDictionary = other;
8550  return [_dictionary isEqual:otherDictionary->_dictionary];
8551}
8552
8553- (NSUInteger)hash {
8554  return _dictionary.count;
8555}
8556
8557- (NSString *)description {
8558  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
8559}
8560
8561- (NSUInteger)count {
8562  return _dictionary.count;
8563}
8564
8565- (void)enumerateKeysAndInt32sUsingBlock:
8566    (void (NS_NOESCAPE ^)(NSString *key, int32_t value, BOOL *stop))block {
8567  BOOL stop = NO;
8568  NSDictionary *internal = _dictionary;
8569  NSEnumerator *keys = [internal keyEnumerator];
8570  NSString *aKey;
8571  while ((aKey = [keys nextObject])) {
8572    NSNumber *aValue = internal[aKey];
8573    block(aKey, [aValue intValue], &stop);
8574    if (stop) {
8575      break;
8576    }
8577  }
8578}
8579
8580- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
8581  NSDictionary *internal = _dictionary;
8582  NSUInteger count = internal.count;
8583  if (count == 0) {
8584    return 0;
8585  }
8586
8587  GPBDataType valueDataType = GPBGetFieldDataType(field);
8588  GPBDataType keyDataType = field.mapKeyDataType;
8589  size_t result = 0;
8590  NSEnumerator *keys = [internal keyEnumerator];
8591  NSString *aKey;
8592  while ((aKey = [keys nextObject])) {
8593    NSNumber *aValue = internal[aKey];
8594    size_t msgSize = ComputeDictStringFieldSize(aKey, kMapKeyFieldNumber, keyDataType);
8595    msgSize += ComputeDictInt32FieldSize([aValue intValue], kMapValueFieldNumber, valueDataType);
8596    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
8597  }
8598  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
8599  result += tagSize * count;
8600  return result;
8601}
8602
8603- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
8604                         asField:(GPBFieldDescriptor *)field {
8605  GPBDataType valueDataType = GPBGetFieldDataType(field);
8606  GPBDataType keyDataType = field.mapKeyDataType;
8607  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
8608  NSDictionary *internal = _dictionary;
8609  NSEnumerator *keys = [internal keyEnumerator];
8610  NSString *aKey;
8611  while ((aKey = [keys nextObject])) {
8612    NSNumber *aValue = internal[aKey];
8613    [outputStream writeInt32NoTag:tag];
8614    // Write the size of the message.
8615    NSString *unwrappedKey = aKey;
8616    int32_t unwrappedValue = [aValue intValue];
8617    size_t msgSize = ComputeDictStringFieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
8618    msgSize += ComputeDictInt32FieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
8619    [outputStream writeInt32NoTag:(int32_t)msgSize];
8620    // Write the fields.
8621    WriteDictStringField(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
8622    WriteDictInt32Field(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
8623  }
8624}
8625
8626- (void)setGPBGenericValue:(GPBGenericValue *)value
8627     forGPBGenericValueKey:(GPBGenericValue *)key {
8628  [_dictionary setObject:@(value->valueInt32) forKey:key->valueString];
8629}
8630
8631- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
8632  [self enumerateKeysAndInt32sUsingBlock:^(NSString *key, int32_t value, __unused BOOL *stop) {
8633      block(key, [NSString stringWithFormat:@"%d", value]);
8634  }];
8635}
8636
8637- (BOOL)getInt32:(nullable int32_t *)value forKey:(NSString *)key {
8638  NSNumber *wrapped = [_dictionary objectForKey:key];
8639  if (wrapped && value) {
8640    *value = [wrapped intValue];
8641  }
8642  return (wrapped != NULL);
8643}
8644
8645- (void)addEntriesFromDictionary:(GPBStringInt32Dictionary *)otherDictionary {
8646  if (otherDictionary) {
8647    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
8648    if (_autocreator) {
8649      GPBAutocreatedDictionaryModified(_autocreator, self);
8650    }
8651  }
8652}
8653
8654- (void)setInt32:(int32_t)value forKey:(NSString *)key {
8655  if (!key) {
8656    [NSException raise:NSInvalidArgumentException
8657                format:@"Attempting to add nil key to a Dictionary"];
8658  }
8659  [_dictionary setObject:@(value) forKey:key];
8660  if (_autocreator) {
8661    GPBAutocreatedDictionaryModified(_autocreator, self);
8662  }
8663}
8664
8665- (void)removeInt32ForKey:(NSString *)aKey {
8666  [_dictionary removeObjectForKey:aKey];
8667}
8668
8669- (void)removeAll {
8670  [_dictionary removeAllObjects];
8671}
8672
8673@end
8674
8675#pragma mark - String -> UInt64
8676
8677@implementation GPBStringUInt64Dictionary {
8678 @package
8679  NSMutableDictionary *_dictionary;
8680}
8681
8682- (instancetype)init {
8683  return [self initWithUInt64s:NULL forKeys:NULL count:0];
8684}
8685
8686- (instancetype)initWithUInt64s:(const uint64_t [])values
8687                        forKeys:(const NSString * [])keys
8688                          count:(NSUInteger)count {
8689  self = [super init];
8690  if (self) {
8691    _dictionary = [[NSMutableDictionary alloc] init];
8692    if (count && values && keys) {
8693      for (NSUInteger i = 0; i < count; ++i) {
8694        if (!keys[i]) {
8695          [NSException raise:NSInvalidArgumentException
8696                      format:@"Attempting to add nil key to a Dictionary"];
8697        }
8698        [_dictionary setObject:@(values[i]) forKey:keys[i]];
8699      }
8700    }
8701  }
8702  return self;
8703}
8704
8705- (instancetype)initWithDictionary:(GPBStringUInt64Dictionary *)dictionary {
8706  self = [self initWithUInt64s:NULL forKeys:NULL count:0];
8707  if (self) {
8708    if (dictionary) {
8709      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
8710    }
8711  }
8712  return self;
8713}
8714
8715- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
8716  return [self initWithUInt64s:NULL forKeys:NULL count:0];
8717}
8718
8719- (void)dealloc {
8720  NSAssert(!_autocreator,
8721           @"%@: Autocreator must be cleared before release, autocreator: %@",
8722           [self class], _autocreator);
8723  [_dictionary release];
8724  [super dealloc];
8725}
8726
8727- (instancetype)copyWithZone:(NSZone *)zone {
8728  return [[GPBStringUInt64Dictionary allocWithZone:zone] initWithDictionary:self];
8729}
8730
8731- (BOOL)isEqual:(id)other {
8732  if (self == other) {
8733    return YES;
8734  }
8735  if (![other isKindOfClass:[GPBStringUInt64Dictionary class]]) {
8736    return NO;
8737  }
8738  GPBStringUInt64Dictionary *otherDictionary = other;
8739  return [_dictionary isEqual:otherDictionary->_dictionary];
8740}
8741
8742- (NSUInteger)hash {
8743  return _dictionary.count;
8744}
8745
8746- (NSString *)description {
8747  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
8748}
8749
8750- (NSUInteger)count {
8751  return _dictionary.count;
8752}
8753
8754- (void)enumerateKeysAndUInt64sUsingBlock:
8755    (void (NS_NOESCAPE ^)(NSString *key, uint64_t value, BOOL *stop))block {
8756  BOOL stop = NO;
8757  NSDictionary *internal = _dictionary;
8758  NSEnumerator *keys = [internal keyEnumerator];
8759  NSString *aKey;
8760  while ((aKey = [keys nextObject])) {
8761    NSNumber *aValue = internal[aKey];
8762    block(aKey, [aValue unsignedLongLongValue], &stop);
8763    if (stop) {
8764      break;
8765    }
8766  }
8767}
8768
8769- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
8770  NSDictionary *internal = _dictionary;
8771  NSUInteger count = internal.count;
8772  if (count == 0) {
8773    return 0;
8774  }
8775
8776  GPBDataType valueDataType = GPBGetFieldDataType(field);
8777  GPBDataType keyDataType = field.mapKeyDataType;
8778  size_t result = 0;
8779  NSEnumerator *keys = [internal keyEnumerator];
8780  NSString *aKey;
8781  while ((aKey = [keys nextObject])) {
8782    NSNumber *aValue = internal[aKey];
8783    size_t msgSize = ComputeDictStringFieldSize(aKey, kMapKeyFieldNumber, keyDataType);
8784    msgSize += ComputeDictUInt64FieldSize([aValue unsignedLongLongValue], kMapValueFieldNumber, valueDataType);
8785    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
8786  }
8787  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
8788  result += tagSize * count;
8789  return result;
8790}
8791
8792- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
8793                         asField:(GPBFieldDescriptor *)field {
8794  GPBDataType valueDataType = GPBGetFieldDataType(field);
8795  GPBDataType keyDataType = field.mapKeyDataType;
8796  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
8797  NSDictionary *internal = _dictionary;
8798  NSEnumerator *keys = [internal keyEnumerator];
8799  NSString *aKey;
8800  while ((aKey = [keys nextObject])) {
8801    NSNumber *aValue = internal[aKey];
8802    [outputStream writeInt32NoTag:tag];
8803    // Write the size of the message.
8804    NSString *unwrappedKey = aKey;
8805    uint64_t unwrappedValue = [aValue unsignedLongLongValue];
8806    size_t msgSize = ComputeDictStringFieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
8807    msgSize += ComputeDictUInt64FieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
8808    [outputStream writeInt32NoTag:(int32_t)msgSize];
8809    // Write the fields.
8810    WriteDictStringField(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
8811    WriteDictUInt64Field(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
8812  }
8813}
8814
8815- (void)setGPBGenericValue:(GPBGenericValue *)value
8816     forGPBGenericValueKey:(GPBGenericValue *)key {
8817  [_dictionary setObject:@(value->valueUInt64) forKey:key->valueString];
8818}
8819
8820- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
8821  [self enumerateKeysAndUInt64sUsingBlock:^(NSString *key, uint64_t value, __unused BOOL *stop) {
8822      block(key, [NSString stringWithFormat:@"%llu", value]);
8823  }];
8824}
8825
8826- (BOOL)getUInt64:(nullable uint64_t *)value forKey:(NSString *)key {
8827  NSNumber *wrapped = [_dictionary objectForKey:key];
8828  if (wrapped && value) {
8829    *value = [wrapped unsignedLongLongValue];
8830  }
8831  return (wrapped != NULL);
8832}
8833
8834- (void)addEntriesFromDictionary:(GPBStringUInt64Dictionary *)otherDictionary {
8835  if (otherDictionary) {
8836    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
8837    if (_autocreator) {
8838      GPBAutocreatedDictionaryModified(_autocreator, self);
8839    }
8840  }
8841}
8842
8843- (void)setUInt64:(uint64_t)value forKey:(NSString *)key {
8844  if (!key) {
8845    [NSException raise:NSInvalidArgumentException
8846                format:@"Attempting to add nil key to a Dictionary"];
8847  }
8848  [_dictionary setObject:@(value) forKey:key];
8849  if (_autocreator) {
8850    GPBAutocreatedDictionaryModified(_autocreator, self);
8851  }
8852}
8853
8854- (void)removeUInt64ForKey:(NSString *)aKey {
8855  [_dictionary removeObjectForKey:aKey];
8856}
8857
8858- (void)removeAll {
8859  [_dictionary removeAllObjects];
8860}
8861
8862@end
8863
8864#pragma mark - String -> Int64
8865
8866@implementation GPBStringInt64Dictionary {
8867 @package
8868  NSMutableDictionary *_dictionary;
8869}
8870
8871- (instancetype)init {
8872  return [self initWithInt64s:NULL forKeys:NULL count:0];
8873}
8874
8875- (instancetype)initWithInt64s:(const int64_t [])values
8876                       forKeys:(const NSString * [])keys
8877                         count:(NSUInteger)count {
8878  self = [super init];
8879  if (self) {
8880    _dictionary = [[NSMutableDictionary alloc] init];
8881    if (count && values && keys) {
8882      for (NSUInteger i = 0; i < count; ++i) {
8883        if (!keys[i]) {
8884          [NSException raise:NSInvalidArgumentException
8885                      format:@"Attempting to add nil key to a Dictionary"];
8886        }
8887        [_dictionary setObject:@(values[i]) forKey:keys[i]];
8888      }
8889    }
8890  }
8891  return self;
8892}
8893
8894- (instancetype)initWithDictionary:(GPBStringInt64Dictionary *)dictionary {
8895  self = [self initWithInt64s:NULL forKeys:NULL count:0];
8896  if (self) {
8897    if (dictionary) {
8898      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
8899    }
8900  }
8901  return self;
8902}
8903
8904- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
8905  return [self initWithInt64s:NULL forKeys:NULL count:0];
8906}
8907
8908- (void)dealloc {
8909  NSAssert(!_autocreator,
8910           @"%@: Autocreator must be cleared before release, autocreator: %@",
8911           [self class], _autocreator);
8912  [_dictionary release];
8913  [super dealloc];
8914}
8915
8916- (instancetype)copyWithZone:(NSZone *)zone {
8917  return [[GPBStringInt64Dictionary allocWithZone:zone] initWithDictionary:self];
8918}
8919
8920- (BOOL)isEqual:(id)other {
8921  if (self == other) {
8922    return YES;
8923  }
8924  if (![other isKindOfClass:[GPBStringInt64Dictionary class]]) {
8925    return NO;
8926  }
8927  GPBStringInt64Dictionary *otherDictionary = other;
8928  return [_dictionary isEqual:otherDictionary->_dictionary];
8929}
8930
8931- (NSUInteger)hash {
8932  return _dictionary.count;
8933}
8934
8935- (NSString *)description {
8936  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
8937}
8938
8939- (NSUInteger)count {
8940  return _dictionary.count;
8941}
8942
8943- (void)enumerateKeysAndInt64sUsingBlock:
8944    (void (NS_NOESCAPE ^)(NSString *key, int64_t value, BOOL *stop))block {
8945  BOOL stop = NO;
8946  NSDictionary *internal = _dictionary;
8947  NSEnumerator *keys = [internal keyEnumerator];
8948  NSString *aKey;
8949  while ((aKey = [keys nextObject])) {
8950    NSNumber *aValue = internal[aKey];
8951    block(aKey, [aValue longLongValue], &stop);
8952    if (stop) {
8953      break;
8954    }
8955  }
8956}
8957
8958- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
8959  NSDictionary *internal = _dictionary;
8960  NSUInteger count = internal.count;
8961  if (count == 0) {
8962    return 0;
8963  }
8964
8965  GPBDataType valueDataType = GPBGetFieldDataType(field);
8966  GPBDataType keyDataType = field.mapKeyDataType;
8967  size_t result = 0;
8968  NSEnumerator *keys = [internal keyEnumerator];
8969  NSString *aKey;
8970  while ((aKey = [keys nextObject])) {
8971    NSNumber *aValue = internal[aKey];
8972    size_t msgSize = ComputeDictStringFieldSize(aKey, kMapKeyFieldNumber, keyDataType);
8973    msgSize += ComputeDictInt64FieldSize([aValue longLongValue], kMapValueFieldNumber, valueDataType);
8974    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
8975  }
8976  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
8977  result += tagSize * count;
8978  return result;
8979}
8980
8981- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
8982                         asField:(GPBFieldDescriptor *)field {
8983  GPBDataType valueDataType = GPBGetFieldDataType(field);
8984  GPBDataType keyDataType = field.mapKeyDataType;
8985  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
8986  NSDictionary *internal = _dictionary;
8987  NSEnumerator *keys = [internal keyEnumerator];
8988  NSString *aKey;
8989  while ((aKey = [keys nextObject])) {
8990    NSNumber *aValue = internal[aKey];
8991    [outputStream writeInt32NoTag:tag];
8992    // Write the size of the message.
8993    NSString *unwrappedKey = aKey;
8994    int64_t unwrappedValue = [aValue longLongValue];
8995    size_t msgSize = ComputeDictStringFieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
8996    msgSize += ComputeDictInt64FieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
8997    [outputStream writeInt32NoTag:(int32_t)msgSize];
8998    // Write the fields.
8999    WriteDictStringField(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
9000    WriteDictInt64Field(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
9001  }
9002}
9003
9004- (void)setGPBGenericValue:(GPBGenericValue *)value
9005     forGPBGenericValueKey:(GPBGenericValue *)key {
9006  [_dictionary setObject:@(value->valueInt64) forKey:key->valueString];
9007}
9008
9009- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
9010  [self enumerateKeysAndInt64sUsingBlock:^(NSString *key, int64_t value, __unused BOOL *stop) {
9011      block(key, [NSString stringWithFormat:@"%lld", value]);
9012  }];
9013}
9014
9015- (BOOL)getInt64:(nullable int64_t *)value forKey:(NSString *)key {
9016  NSNumber *wrapped = [_dictionary objectForKey:key];
9017  if (wrapped && value) {
9018    *value = [wrapped longLongValue];
9019  }
9020  return (wrapped != NULL);
9021}
9022
9023- (void)addEntriesFromDictionary:(GPBStringInt64Dictionary *)otherDictionary {
9024  if (otherDictionary) {
9025    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
9026    if (_autocreator) {
9027      GPBAutocreatedDictionaryModified(_autocreator, self);
9028    }
9029  }
9030}
9031
9032- (void)setInt64:(int64_t)value forKey:(NSString *)key {
9033  if (!key) {
9034    [NSException raise:NSInvalidArgumentException
9035                format:@"Attempting to add nil key to a Dictionary"];
9036  }
9037  [_dictionary setObject:@(value) forKey:key];
9038  if (_autocreator) {
9039    GPBAutocreatedDictionaryModified(_autocreator, self);
9040  }
9041}
9042
9043- (void)removeInt64ForKey:(NSString *)aKey {
9044  [_dictionary removeObjectForKey:aKey];
9045}
9046
9047- (void)removeAll {
9048  [_dictionary removeAllObjects];
9049}
9050
9051@end
9052
9053#pragma mark - String -> Bool
9054
9055@implementation GPBStringBoolDictionary {
9056 @package
9057  NSMutableDictionary *_dictionary;
9058}
9059
9060- (instancetype)init {
9061  return [self initWithBools:NULL forKeys:NULL count:0];
9062}
9063
9064- (instancetype)initWithBools:(const BOOL [])values
9065                      forKeys:(const NSString * [])keys
9066                        count:(NSUInteger)count {
9067  self = [super init];
9068  if (self) {
9069    _dictionary = [[NSMutableDictionary alloc] init];
9070    if (count && values && keys) {
9071      for (NSUInteger i = 0; i < count; ++i) {
9072        if (!keys[i]) {
9073          [NSException raise:NSInvalidArgumentException
9074                      format:@"Attempting to add nil key to a Dictionary"];
9075        }
9076        [_dictionary setObject:@(values[i]) forKey:keys[i]];
9077      }
9078    }
9079  }
9080  return self;
9081}
9082
9083- (instancetype)initWithDictionary:(GPBStringBoolDictionary *)dictionary {
9084  self = [self initWithBools:NULL forKeys:NULL count:0];
9085  if (self) {
9086    if (dictionary) {
9087      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
9088    }
9089  }
9090  return self;
9091}
9092
9093- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
9094  return [self initWithBools:NULL forKeys:NULL count:0];
9095}
9096
9097- (void)dealloc {
9098  NSAssert(!_autocreator,
9099           @"%@: Autocreator must be cleared before release, autocreator: %@",
9100           [self class], _autocreator);
9101  [_dictionary release];
9102  [super dealloc];
9103}
9104
9105- (instancetype)copyWithZone:(NSZone *)zone {
9106  return [[GPBStringBoolDictionary allocWithZone:zone] initWithDictionary:self];
9107}
9108
9109- (BOOL)isEqual:(id)other {
9110  if (self == other) {
9111    return YES;
9112  }
9113  if (![other isKindOfClass:[GPBStringBoolDictionary class]]) {
9114    return NO;
9115  }
9116  GPBStringBoolDictionary *otherDictionary = other;
9117  return [_dictionary isEqual:otherDictionary->_dictionary];
9118}
9119
9120- (NSUInteger)hash {
9121  return _dictionary.count;
9122}
9123
9124- (NSString *)description {
9125  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
9126}
9127
9128- (NSUInteger)count {
9129  return _dictionary.count;
9130}
9131
9132- (void)enumerateKeysAndBoolsUsingBlock:
9133    (void (NS_NOESCAPE ^)(NSString *key, BOOL value, BOOL *stop))block {
9134  BOOL stop = NO;
9135  NSDictionary *internal = _dictionary;
9136  NSEnumerator *keys = [internal keyEnumerator];
9137  NSString *aKey;
9138  while ((aKey = [keys nextObject])) {
9139    NSNumber *aValue = internal[aKey];
9140    block(aKey, [aValue boolValue], &stop);
9141    if (stop) {
9142      break;
9143    }
9144  }
9145}
9146
9147- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
9148  NSDictionary *internal = _dictionary;
9149  NSUInteger count = internal.count;
9150  if (count == 0) {
9151    return 0;
9152  }
9153
9154  GPBDataType valueDataType = GPBGetFieldDataType(field);
9155  GPBDataType keyDataType = field.mapKeyDataType;
9156  size_t result = 0;
9157  NSEnumerator *keys = [internal keyEnumerator];
9158  NSString *aKey;
9159  while ((aKey = [keys nextObject])) {
9160    NSNumber *aValue = internal[aKey];
9161    size_t msgSize = ComputeDictStringFieldSize(aKey, kMapKeyFieldNumber, keyDataType);
9162    msgSize += ComputeDictBoolFieldSize([aValue boolValue], kMapValueFieldNumber, valueDataType);
9163    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
9164  }
9165  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
9166  result += tagSize * count;
9167  return result;
9168}
9169
9170- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
9171                         asField:(GPBFieldDescriptor *)field {
9172  GPBDataType valueDataType = GPBGetFieldDataType(field);
9173  GPBDataType keyDataType = field.mapKeyDataType;
9174  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
9175  NSDictionary *internal = _dictionary;
9176  NSEnumerator *keys = [internal keyEnumerator];
9177  NSString *aKey;
9178  while ((aKey = [keys nextObject])) {
9179    NSNumber *aValue = internal[aKey];
9180    [outputStream writeInt32NoTag:tag];
9181    // Write the size of the message.
9182    NSString *unwrappedKey = aKey;
9183    BOOL unwrappedValue = [aValue boolValue];
9184    size_t msgSize = ComputeDictStringFieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
9185    msgSize += ComputeDictBoolFieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
9186    [outputStream writeInt32NoTag:(int32_t)msgSize];
9187    // Write the fields.
9188    WriteDictStringField(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
9189    WriteDictBoolField(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
9190  }
9191}
9192
9193- (void)setGPBGenericValue:(GPBGenericValue *)value
9194     forGPBGenericValueKey:(GPBGenericValue *)key {
9195  [_dictionary setObject:@(value->valueBool) forKey:key->valueString];
9196}
9197
9198- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
9199  [self enumerateKeysAndBoolsUsingBlock:^(NSString *key, BOOL value, __unused BOOL *stop) {
9200      block(key, (value ? @"true" : @"false"));
9201  }];
9202}
9203
9204- (BOOL)getBool:(nullable BOOL *)value forKey:(NSString *)key {
9205  NSNumber *wrapped = [_dictionary objectForKey:key];
9206  if (wrapped && value) {
9207    *value = [wrapped boolValue];
9208  }
9209  return (wrapped != NULL);
9210}
9211
9212- (void)addEntriesFromDictionary:(GPBStringBoolDictionary *)otherDictionary {
9213  if (otherDictionary) {
9214    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
9215    if (_autocreator) {
9216      GPBAutocreatedDictionaryModified(_autocreator, self);
9217    }
9218  }
9219}
9220
9221- (void)setBool:(BOOL)value forKey:(NSString *)key {
9222  if (!key) {
9223    [NSException raise:NSInvalidArgumentException
9224                format:@"Attempting to add nil key to a Dictionary"];
9225  }
9226  [_dictionary setObject:@(value) forKey:key];
9227  if (_autocreator) {
9228    GPBAutocreatedDictionaryModified(_autocreator, self);
9229  }
9230}
9231
9232- (void)removeBoolForKey:(NSString *)aKey {
9233  [_dictionary removeObjectForKey:aKey];
9234}
9235
9236- (void)removeAll {
9237  [_dictionary removeAllObjects];
9238}
9239
9240@end
9241
9242#pragma mark - String -> Float
9243
9244@implementation GPBStringFloatDictionary {
9245 @package
9246  NSMutableDictionary *_dictionary;
9247}
9248
9249- (instancetype)init {
9250  return [self initWithFloats:NULL forKeys:NULL count:0];
9251}
9252
9253- (instancetype)initWithFloats:(const float [])values
9254                       forKeys:(const NSString * [])keys
9255                         count:(NSUInteger)count {
9256  self = [super init];
9257  if (self) {
9258    _dictionary = [[NSMutableDictionary alloc] init];
9259    if (count && values && keys) {
9260      for (NSUInteger i = 0; i < count; ++i) {
9261        if (!keys[i]) {
9262          [NSException raise:NSInvalidArgumentException
9263                      format:@"Attempting to add nil key to a Dictionary"];
9264        }
9265        [_dictionary setObject:@(values[i]) forKey:keys[i]];
9266      }
9267    }
9268  }
9269  return self;
9270}
9271
9272- (instancetype)initWithDictionary:(GPBStringFloatDictionary *)dictionary {
9273  self = [self initWithFloats:NULL forKeys:NULL count:0];
9274  if (self) {
9275    if (dictionary) {
9276      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
9277    }
9278  }
9279  return self;
9280}
9281
9282- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
9283  return [self initWithFloats:NULL forKeys:NULL count:0];
9284}
9285
9286- (void)dealloc {
9287  NSAssert(!_autocreator,
9288           @"%@: Autocreator must be cleared before release, autocreator: %@",
9289           [self class], _autocreator);
9290  [_dictionary release];
9291  [super dealloc];
9292}
9293
9294- (instancetype)copyWithZone:(NSZone *)zone {
9295  return [[GPBStringFloatDictionary allocWithZone:zone] initWithDictionary:self];
9296}
9297
9298- (BOOL)isEqual:(id)other {
9299  if (self == other) {
9300    return YES;
9301  }
9302  if (![other isKindOfClass:[GPBStringFloatDictionary class]]) {
9303    return NO;
9304  }
9305  GPBStringFloatDictionary *otherDictionary = other;
9306  return [_dictionary isEqual:otherDictionary->_dictionary];
9307}
9308
9309- (NSUInteger)hash {
9310  return _dictionary.count;
9311}
9312
9313- (NSString *)description {
9314  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
9315}
9316
9317- (NSUInteger)count {
9318  return _dictionary.count;
9319}
9320
9321- (void)enumerateKeysAndFloatsUsingBlock:
9322    (void (NS_NOESCAPE ^)(NSString *key, float value, BOOL *stop))block {
9323  BOOL stop = NO;
9324  NSDictionary *internal = _dictionary;
9325  NSEnumerator *keys = [internal keyEnumerator];
9326  NSString *aKey;
9327  while ((aKey = [keys nextObject])) {
9328    NSNumber *aValue = internal[aKey];
9329    block(aKey, [aValue floatValue], &stop);
9330    if (stop) {
9331      break;
9332    }
9333  }
9334}
9335
9336- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
9337  NSDictionary *internal = _dictionary;
9338  NSUInteger count = internal.count;
9339  if (count == 0) {
9340    return 0;
9341  }
9342
9343  GPBDataType valueDataType = GPBGetFieldDataType(field);
9344  GPBDataType keyDataType = field.mapKeyDataType;
9345  size_t result = 0;
9346  NSEnumerator *keys = [internal keyEnumerator];
9347  NSString *aKey;
9348  while ((aKey = [keys nextObject])) {
9349    NSNumber *aValue = internal[aKey];
9350    size_t msgSize = ComputeDictStringFieldSize(aKey, kMapKeyFieldNumber, keyDataType);
9351    msgSize += ComputeDictFloatFieldSize([aValue floatValue], kMapValueFieldNumber, valueDataType);
9352    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
9353  }
9354  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
9355  result += tagSize * count;
9356  return result;
9357}
9358
9359- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
9360                         asField:(GPBFieldDescriptor *)field {
9361  GPBDataType valueDataType = GPBGetFieldDataType(field);
9362  GPBDataType keyDataType = field.mapKeyDataType;
9363  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
9364  NSDictionary *internal = _dictionary;
9365  NSEnumerator *keys = [internal keyEnumerator];
9366  NSString *aKey;
9367  while ((aKey = [keys nextObject])) {
9368    NSNumber *aValue = internal[aKey];
9369    [outputStream writeInt32NoTag:tag];
9370    // Write the size of the message.
9371    NSString *unwrappedKey = aKey;
9372    float unwrappedValue = [aValue floatValue];
9373    size_t msgSize = ComputeDictStringFieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
9374    msgSize += ComputeDictFloatFieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
9375    [outputStream writeInt32NoTag:(int32_t)msgSize];
9376    // Write the fields.
9377    WriteDictStringField(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
9378    WriteDictFloatField(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
9379  }
9380}
9381
9382- (void)setGPBGenericValue:(GPBGenericValue *)value
9383     forGPBGenericValueKey:(GPBGenericValue *)key {
9384  [_dictionary setObject:@(value->valueFloat) forKey:key->valueString];
9385}
9386
9387- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
9388  [self enumerateKeysAndFloatsUsingBlock:^(NSString *key, float value, __unused BOOL *stop) {
9389      block(key, [NSString stringWithFormat:@"%.*g", FLT_DIG, value]);
9390  }];
9391}
9392
9393- (BOOL)getFloat:(nullable float *)value forKey:(NSString *)key {
9394  NSNumber *wrapped = [_dictionary objectForKey:key];
9395  if (wrapped && value) {
9396    *value = [wrapped floatValue];
9397  }
9398  return (wrapped != NULL);
9399}
9400
9401- (void)addEntriesFromDictionary:(GPBStringFloatDictionary *)otherDictionary {
9402  if (otherDictionary) {
9403    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
9404    if (_autocreator) {
9405      GPBAutocreatedDictionaryModified(_autocreator, self);
9406    }
9407  }
9408}
9409
9410- (void)setFloat:(float)value forKey:(NSString *)key {
9411  if (!key) {
9412    [NSException raise:NSInvalidArgumentException
9413                format:@"Attempting to add nil key to a Dictionary"];
9414  }
9415  [_dictionary setObject:@(value) forKey:key];
9416  if (_autocreator) {
9417    GPBAutocreatedDictionaryModified(_autocreator, self);
9418  }
9419}
9420
9421- (void)removeFloatForKey:(NSString *)aKey {
9422  [_dictionary removeObjectForKey:aKey];
9423}
9424
9425- (void)removeAll {
9426  [_dictionary removeAllObjects];
9427}
9428
9429@end
9430
9431#pragma mark - String -> Double
9432
9433@implementation GPBStringDoubleDictionary {
9434 @package
9435  NSMutableDictionary *_dictionary;
9436}
9437
9438- (instancetype)init {
9439  return [self initWithDoubles:NULL forKeys:NULL count:0];
9440}
9441
9442- (instancetype)initWithDoubles:(const double [])values
9443                        forKeys:(const NSString * [])keys
9444                          count:(NSUInteger)count {
9445  self = [super init];
9446  if (self) {
9447    _dictionary = [[NSMutableDictionary alloc] init];
9448    if (count && values && keys) {
9449      for (NSUInteger i = 0; i < count; ++i) {
9450        if (!keys[i]) {
9451          [NSException raise:NSInvalidArgumentException
9452                      format:@"Attempting to add nil key to a Dictionary"];
9453        }
9454        [_dictionary setObject:@(values[i]) forKey:keys[i]];
9455      }
9456    }
9457  }
9458  return self;
9459}
9460
9461- (instancetype)initWithDictionary:(GPBStringDoubleDictionary *)dictionary {
9462  self = [self initWithDoubles:NULL forKeys:NULL count:0];
9463  if (self) {
9464    if (dictionary) {
9465      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
9466    }
9467  }
9468  return self;
9469}
9470
9471- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
9472  return [self initWithDoubles:NULL forKeys:NULL count:0];
9473}
9474
9475- (void)dealloc {
9476  NSAssert(!_autocreator,
9477           @"%@: Autocreator must be cleared before release, autocreator: %@",
9478           [self class], _autocreator);
9479  [_dictionary release];
9480  [super dealloc];
9481}
9482
9483- (instancetype)copyWithZone:(NSZone *)zone {
9484  return [[GPBStringDoubleDictionary allocWithZone:zone] initWithDictionary:self];
9485}
9486
9487- (BOOL)isEqual:(id)other {
9488  if (self == other) {
9489    return YES;
9490  }
9491  if (![other isKindOfClass:[GPBStringDoubleDictionary class]]) {
9492    return NO;
9493  }
9494  GPBStringDoubleDictionary *otherDictionary = other;
9495  return [_dictionary isEqual:otherDictionary->_dictionary];
9496}
9497
9498- (NSUInteger)hash {
9499  return _dictionary.count;
9500}
9501
9502- (NSString *)description {
9503  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
9504}
9505
9506- (NSUInteger)count {
9507  return _dictionary.count;
9508}
9509
9510- (void)enumerateKeysAndDoublesUsingBlock:
9511    (void (NS_NOESCAPE ^)(NSString *key, double value, BOOL *stop))block {
9512  BOOL stop = NO;
9513  NSDictionary *internal = _dictionary;
9514  NSEnumerator *keys = [internal keyEnumerator];
9515  NSString *aKey;
9516  while ((aKey = [keys nextObject])) {
9517    NSNumber *aValue = internal[aKey];
9518    block(aKey, [aValue doubleValue], &stop);
9519    if (stop) {
9520      break;
9521    }
9522  }
9523}
9524
9525- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
9526  NSDictionary *internal = _dictionary;
9527  NSUInteger count = internal.count;
9528  if (count == 0) {
9529    return 0;
9530  }
9531
9532  GPBDataType valueDataType = GPBGetFieldDataType(field);
9533  GPBDataType keyDataType = field.mapKeyDataType;
9534  size_t result = 0;
9535  NSEnumerator *keys = [internal keyEnumerator];
9536  NSString *aKey;
9537  while ((aKey = [keys nextObject])) {
9538    NSNumber *aValue = internal[aKey];
9539    size_t msgSize = ComputeDictStringFieldSize(aKey, kMapKeyFieldNumber, keyDataType);
9540    msgSize += ComputeDictDoubleFieldSize([aValue doubleValue], kMapValueFieldNumber, valueDataType);
9541    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
9542  }
9543  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
9544  result += tagSize * count;
9545  return result;
9546}
9547
9548- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
9549                         asField:(GPBFieldDescriptor *)field {
9550  GPBDataType valueDataType = GPBGetFieldDataType(field);
9551  GPBDataType keyDataType = field.mapKeyDataType;
9552  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
9553  NSDictionary *internal = _dictionary;
9554  NSEnumerator *keys = [internal keyEnumerator];
9555  NSString *aKey;
9556  while ((aKey = [keys nextObject])) {
9557    NSNumber *aValue = internal[aKey];
9558    [outputStream writeInt32NoTag:tag];
9559    // Write the size of the message.
9560    NSString *unwrappedKey = aKey;
9561    double unwrappedValue = [aValue doubleValue];
9562    size_t msgSize = ComputeDictStringFieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
9563    msgSize += ComputeDictDoubleFieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
9564    [outputStream writeInt32NoTag:(int32_t)msgSize];
9565    // Write the fields.
9566    WriteDictStringField(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
9567    WriteDictDoubleField(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
9568  }
9569}
9570
9571- (void)setGPBGenericValue:(GPBGenericValue *)value
9572     forGPBGenericValueKey:(GPBGenericValue *)key {
9573  [_dictionary setObject:@(value->valueDouble) forKey:key->valueString];
9574}
9575
9576- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
9577  [self enumerateKeysAndDoublesUsingBlock:^(NSString *key, double value, __unused BOOL *stop) {
9578      block(key, [NSString stringWithFormat:@"%.*lg", DBL_DIG, value]);
9579  }];
9580}
9581
9582- (BOOL)getDouble:(nullable double *)value forKey:(NSString *)key {
9583  NSNumber *wrapped = [_dictionary objectForKey:key];
9584  if (wrapped && value) {
9585    *value = [wrapped doubleValue];
9586  }
9587  return (wrapped != NULL);
9588}
9589
9590- (void)addEntriesFromDictionary:(GPBStringDoubleDictionary *)otherDictionary {
9591  if (otherDictionary) {
9592    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
9593    if (_autocreator) {
9594      GPBAutocreatedDictionaryModified(_autocreator, self);
9595    }
9596  }
9597}
9598
9599- (void)setDouble:(double)value forKey:(NSString *)key {
9600  if (!key) {
9601    [NSException raise:NSInvalidArgumentException
9602                format:@"Attempting to add nil key to a Dictionary"];
9603  }
9604  [_dictionary setObject:@(value) forKey:key];
9605  if (_autocreator) {
9606    GPBAutocreatedDictionaryModified(_autocreator, self);
9607  }
9608}
9609
9610- (void)removeDoubleForKey:(NSString *)aKey {
9611  [_dictionary removeObjectForKey:aKey];
9612}
9613
9614- (void)removeAll {
9615  [_dictionary removeAllObjects];
9616}
9617
9618@end
9619
9620#pragma mark - String -> Enum
9621
9622@implementation GPBStringEnumDictionary {
9623 @package
9624  NSMutableDictionary *_dictionary;
9625  GPBEnumValidationFunc _validationFunc;
9626}
9627
9628@synthesize validationFunc = _validationFunc;
9629
9630- (instancetype)init {
9631  return [self initWithValidationFunction:NULL rawValues:NULL forKeys:NULL count:0];
9632}
9633
9634- (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func {
9635  return [self initWithValidationFunction:func rawValues:NULL forKeys:NULL count:0];
9636}
9637
9638- (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func
9639                                 rawValues:(const int32_t [])rawValues
9640                                   forKeys:(const NSString * [])keys
9641                                     count:(NSUInteger)count {
9642  self = [super init];
9643  if (self) {
9644    _dictionary = [[NSMutableDictionary alloc] init];
9645    _validationFunc = (func != NULL ? func : DictDefault_IsValidValue);
9646    if (count && rawValues && keys) {
9647      for (NSUInteger i = 0; i < count; ++i) {
9648        if (!keys[i]) {
9649          [NSException raise:NSInvalidArgumentException
9650                      format:@"Attempting to add nil key to a Dictionary"];
9651        }
9652        [_dictionary setObject:@(rawValues[i]) forKey:keys[i]];
9653      }
9654    }
9655  }
9656  return self;
9657}
9658
9659- (instancetype)initWithDictionary:(GPBStringEnumDictionary *)dictionary {
9660  self = [self initWithValidationFunction:dictionary.validationFunc
9661                                rawValues:NULL
9662                                  forKeys:NULL
9663                                    count:0];
9664  if (self) {
9665    if (dictionary) {
9666      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
9667    }
9668  }
9669  return self;
9670}
9671
9672- (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func
9673                                  capacity:(__unused NSUInteger)numItems {
9674  return [self initWithValidationFunction:func rawValues:NULL forKeys:NULL count:0];
9675}
9676
9677- (void)dealloc {
9678  NSAssert(!_autocreator,
9679           @"%@: Autocreator must be cleared before release, autocreator: %@",
9680           [self class], _autocreator);
9681  [_dictionary release];
9682  [super dealloc];
9683}
9684
9685- (instancetype)copyWithZone:(NSZone *)zone {
9686  return [[GPBStringEnumDictionary allocWithZone:zone] initWithDictionary:self];
9687}
9688
9689- (BOOL)isEqual:(id)other {
9690  if (self == other) {
9691    return YES;
9692  }
9693  if (![other isKindOfClass:[GPBStringEnumDictionary class]]) {
9694    return NO;
9695  }
9696  GPBStringEnumDictionary *otherDictionary = other;
9697  return [_dictionary isEqual:otherDictionary->_dictionary];
9698}
9699
9700- (NSUInteger)hash {
9701  return _dictionary.count;
9702}
9703
9704- (NSString *)description {
9705  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
9706}
9707
9708- (NSUInteger)count {
9709  return _dictionary.count;
9710}
9711
9712- (void)enumerateKeysAndRawValuesUsingBlock:
9713    (void (NS_NOESCAPE ^)(NSString *key, int32_t value, BOOL *stop))block {
9714  BOOL stop = NO;
9715  NSDictionary *internal = _dictionary;
9716  NSEnumerator *keys = [internal keyEnumerator];
9717  NSString *aKey;
9718  while ((aKey = [keys nextObject])) {
9719    NSNumber *aValue = internal[aKey];
9720    block(aKey, [aValue intValue], &stop);
9721    if (stop) {
9722      break;
9723    }
9724  }
9725}
9726
9727- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
9728  NSDictionary *internal = _dictionary;
9729  NSUInteger count = internal.count;
9730  if (count == 0) {
9731    return 0;
9732  }
9733
9734  GPBDataType valueDataType = GPBGetFieldDataType(field);
9735  GPBDataType keyDataType = field.mapKeyDataType;
9736  size_t result = 0;
9737  NSEnumerator *keys = [internal keyEnumerator];
9738  NSString *aKey;
9739  while ((aKey = [keys nextObject])) {
9740    NSNumber *aValue = internal[aKey];
9741    size_t msgSize = ComputeDictStringFieldSize(aKey, kMapKeyFieldNumber, keyDataType);
9742    msgSize += ComputeDictEnumFieldSize([aValue intValue], kMapValueFieldNumber, valueDataType);
9743    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
9744  }
9745  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
9746  result += tagSize * count;
9747  return result;
9748}
9749
9750- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
9751                         asField:(GPBFieldDescriptor *)field {
9752  GPBDataType valueDataType = GPBGetFieldDataType(field);
9753  GPBDataType keyDataType = field.mapKeyDataType;
9754  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
9755  NSDictionary *internal = _dictionary;
9756  NSEnumerator *keys = [internal keyEnumerator];
9757  NSString *aKey;
9758  while ((aKey = [keys nextObject])) {
9759    NSNumber *aValue = internal[aKey];
9760    [outputStream writeInt32NoTag:tag];
9761    // Write the size of the message.
9762    NSString *unwrappedKey = aKey;
9763    int32_t unwrappedValue = [aValue intValue];
9764    size_t msgSize = ComputeDictStringFieldSize(unwrappedKey, kMapKeyFieldNumber, keyDataType);
9765    msgSize += ComputeDictEnumFieldSize(unwrappedValue, kMapValueFieldNumber, valueDataType);
9766    [outputStream writeInt32NoTag:(int32_t)msgSize];
9767    // Write the fields.
9768    WriteDictStringField(outputStream, unwrappedKey, kMapKeyFieldNumber, keyDataType);
9769    WriteDictEnumField(outputStream, unwrappedValue, kMapValueFieldNumber, valueDataType);
9770  }
9771}
9772
9773- (NSData *)serializedDataForUnknownValue:(int32_t)value
9774                                   forKey:(GPBGenericValue *)key
9775                              keyDataType:(GPBDataType)keyDataType {
9776  size_t msgSize = ComputeDictStringFieldSize(key->valueString, kMapKeyFieldNumber, keyDataType);
9777  msgSize += ComputeDictEnumFieldSize(value, kMapValueFieldNumber, GPBDataTypeEnum);
9778  NSMutableData *data = [NSMutableData dataWithLength:msgSize];
9779  GPBCodedOutputStream *outputStream = [[GPBCodedOutputStream alloc] initWithData:data];
9780  WriteDictStringField(outputStream, key->valueString, kMapKeyFieldNumber, keyDataType);
9781  WriteDictEnumField(outputStream, value, kMapValueFieldNumber, GPBDataTypeEnum);
9782  [outputStream flush];
9783  [outputStream release];
9784  return data;
9785}
9786- (void)setGPBGenericValue:(GPBGenericValue *)value
9787     forGPBGenericValueKey:(GPBGenericValue *)key {
9788  [_dictionary setObject:@(value->valueEnum) forKey:key->valueString];
9789}
9790
9791- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
9792  [self enumerateKeysAndRawValuesUsingBlock:^(NSString *key, int32_t value, __unused BOOL *stop) {
9793      block(key, @(value));
9794  }];
9795}
9796
9797- (BOOL)getEnum:(int32_t *)value forKey:(NSString *)key {
9798  NSNumber *wrapped = [_dictionary objectForKey:key];
9799  if (wrapped && value) {
9800    int32_t result = [wrapped intValue];
9801    if (!_validationFunc(result)) {
9802      result = kGPBUnrecognizedEnumeratorValue;
9803    }
9804    *value = result;
9805  }
9806  return (wrapped != NULL);
9807}
9808
9809- (BOOL)getRawValue:(int32_t *)rawValue forKey:(NSString *)key {
9810  NSNumber *wrapped = [_dictionary objectForKey:key];
9811  if (wrapped && rawValue) {
9812    *rawValue = [wrapped intValue];
9813  }
9814  return (wrapped != NULL);
9815}
9816
9817- (void)enumerateKeysAndEnumsUsingBlock:
9818    (void (NS_NOESCAPE ^)(NSString *key, int32_t value, BOOL *stop))block {
9819  GPBEnumValidationFunc func = _validationFunc;
9820  BOOL stop = NO;
9821  NSEnumerator *keys = [_dictionary keyEnumerator];
9822  NSString *aKey;
9823  while ((aKey = [keys nextObject])) {
9824    NSNumber *aValue = _dictionary[aKey];
9825      int32_t unwrapped = [aValue intValue];
9826      if (!func(unwrapped)) {
9827        unwrapped = kGPBUnrecognizedEnumeratorValue;
9828      }
9829    block(aKey, unwrapped, &stop);
9830    if (stop) {
9831      break;
9832    }
9833  }
9834}
9835
9836- (void)addRawEntriesFromDictionary:(GPBStringEnumDictionary *)otherDictionary {
9837  if (otherDictionary) {
9838    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
9839    if (_autocreator) {
9840      GPBAutocreatedDictionaryModified(_autocreator, self);
9841    }
9842  }
9843}
9844
9845- (void)setRawValue:(int32_t)value forKey:(NSString *)key {
9846  if (!key) {
9847    [NSException raise:NSInvalidArgumentException
9848                format:@"Attempting to add nil key to a Dictionary"];
9849  }
9850  [_dictionary setObject:@(value) forKey:key];
9851  if (_autocreator) {
9852    GPBAutocreatedDictionaryModified(_autocreator, self);
9853  }
9854}
9855
9856- (void)removeEnumForKey:(NSString *)aKey {
9857  [_dictionary removeObjectForKey:aKey];
9858}
9859
9860- (void)removeAll {
9861  [_dictionary removeAllObjects];
9862}
9863
9864- (void)setEnum:(int32_t)value forKey:(NSString *)key {
9865  if (!key) {
9866    [NSException raise:NSInvalidArgumentException
9867                format:@"Attempting to add nil key to a Dictionary"];
9868  }
9869  if (!_validationFunc(value)) {
9870    [NSException raise:NSInvalidArgumentException
9871                format:@"GPBStringEnumDictionary: Attempt to set an unknown enum value (%d)",
9872                       value];
9873  }
9874
9875  [_dictionary setObject:@(value) forKey:key];
9876  if (_autocreator) {
9877    GPBAutocreatedDictionaryModified(_autocreator, self);
9878  }
9879}
9880
9881@end
9882
9883//%PDDM-EXPAND-END (5 expansions)
9884
9885
9886//%PDDM-EXPAND DICTIONARY_BOOL_KEY_TO_POD_IMPL(UInt32, uint32_t)
9887// This block of code is generated, do not edit it directly.
9888
9889#pragma mark - Bool -> UInt32
9890
9891@implementation GPBBoolUInt32Dictionary {
9892 @package
9893  uint32_t _values[2];
9894  BOOL _valueSet[2];
9895}
9896
9897- (instancetype)init {
9898  return [self initWithUInt32s:NULL forKeys:NULL count:0];
9899}
9900
9901- (instancetype)initWithUInt32s:(const uint32_t [])values
9902                        forKeys:(const BOOL [])keys
9903                          count:(NSUInteger)count {
9904  self = [super init];
9905  if (self) {
9906    for (NSUInteger i = 0; i < count; ++i) {
9907      int idx = keys[i] ? 1 : 0;
9908      _values[idx] = values[i];
9909      _valueSet[idx] = YES;
9910    }
9911  }
9912  return self;
9913}
9914
9915- (instancetype)initWithDictionary:(GPBBoolUInt32Dictionary *)dictionary {
9916  self = [self initWithUInt32s:NULL forKeys:NULL count:0];
9917  if (self) {
9918    if (dictionary) {
9919      for (int i = 0; i < 2; ++i) {
9920        if (dictionary->_valueSet[i]) {
9921          _values[i] = dictionary->_values[i];
9922          _valueSet[i] = YES;
9923        }
9924      }
9925    }
9926  }
9927  return self;
9928}
9929
9930- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
9931  return [self initWithUInt32s:NULL forKeys:NULL count:0];
9932}
9933
9934#if !defined(NS_BLOCK_ASSERTIONS)
9935- (void)dealloc {
9936  NSAssert(!_autocreator,
9937           @"%@: Autocreator must be cleared before release, autocreator: %@",
9938           [self class], _autocreator);
9939  [super dealloc];
9940}
9941#endif  // !defined(NS_BLOCK_ASSERTIONS)
9942
9943- (instancetype)copyWithZone:(NSZone *)zone {
9944  return [[GPBBoolUInt32Dictionary allocWithZone:zone] initWithDictionary:self];
9945}
9946
9947- (BOOL)isEqual:(id)other {
9948  if (self == other) {
9949    return YES;
9950  }
9951  if (![other isKindOfClass:[GPBBoolUInt32Dictionary class]]) {
9952    return NO;
9953  }
9954  GPBBoolUInt32Dictionary *otherDictionary = other;
9955  if ((_valueSet[0] != otherDictionary->_valueSet[0]) ||
9956      (_valueSet[1] != otherDictionary->_valueSet[1])) {
9957    return NO;
9958  }
9959  if ((_valueSet[0] && (_values[0] != otherDictionary->_values[0])) ||
9960      (_valueSet[1] && (_values[1] != otherDictionary->_values[1]))) {
9961    return NO;
9962  }
9963  return YES;
9964}
9965
9966- (NSUInteger)hash {
9967  return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0);
9968}
9969
9970- (NSString *)description {
9971  NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> {", [self class], self];
9972  if (_valueSet[0]) {
9973    [result appendFormat:@"NO: %u", _values[0]];
9974  }
9975  if (_valueSet[1]) {
9976    [result appendFormat:@"YES: %u", _values[1]];
9977  }
9978  [result appendString:@" }"];
9979  return result;
9980}
9981
9982- (NSUInteger)count {
9983  return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0);
9984}
9985
9986- (BOOL)getUInt32:(uint32_t *)value forKey:(BOOL)key {
9987  int idx = (key ? 1 : 0);
9988  if (_valueSet[idx]) {
9989    if (value) {
9990      *value = _values[idx];
9991    }
9992    return YES;
9993  }
9994  return NO;
9995}
9996
9997- (void)setGPBGenericValue:(GPBGenericValue *)value
9998     forGPBGenericValueKey:(GPBGenericValue *)key {
9999  int idx = (key->valueBool ? 1 : 0);
10000  _values[idx] = value->valueUInt32;
10001  _valueSet[idx] = YES;
10002}
10003
10004- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
10005  if (_valueSet[0]) {
10006    block(@"false", [NSString stringWithFormat:@"%u", _values[0]]);
10007  }
10008  if (_valueSet[1]) {
10009    block(@"true", [NSString stringWithFormat:@"%u", _values[1]]);
10010  }
10011}
10012
10013- (void)enumerateKeysAndUInt32sUsingBlock:
10014    (void (NS_NOESCAPE ^)(BOOL key, uint32_t value, BOOL *stop))block {
10015  BOOL stop = NO;
10016  if (_valueSet[0]) {
10017    block(NO, _values[0], &stop);
10018  }
10019  if (!stop && _valueSet[1]) {
10020    block(YES, _values[1], &stop);
10021  }
10022}
10023
10024- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
10025  GPBDataType valueDataType = GPBGetFieldDataType(field);
10026  NSUInteger count = 0;
10027  size_t result = 0;
10028  for (int i = 0; i < 2; ++i) {
10029    if (_valueSet[i]) {
10030      ++count;
10031      size_t msgSize = ComputeDictBoolFieldSize((i == 1), kMapKeyFieldNumber, GPBDataTypeBool);
10032      msgSize += ComputeDictUInt32FieldSize(_values[i], kMapValueFieldNumber, valueDataType);
10033      result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
10034    }
10035  }
10036  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
10037  result += tagSize * count;
10038  return result;
10039}
10040
10041- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
10042                         asField:(GPBFieldDescriptor *)field {
10043  GPBDataType valueDataType = GPBGetFieldDataType(field);
10044  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
10045  for (int i = 0; i < 2; ++i) {
10046    if (_valueSet[i]) {
10047      // Write the tag.
10048      [outputStream writeInt32NoTag:tag];
10049      // Write the size of the message.
10050      size_t msgSize = ComputeDictBoolFieldSize((i == 1), kMapKeyFieldNumber, GPBDataTypeBool);
10051      msgSize += ComputeDictUInt32FieldSize(_values[i], kMapValueFieldNumber, valueDataType);
10052      [outputStream writeInt32NoTag:(int32_t)msgSize];
10053      // Write the fields.
10054      WriteDictBoolField(outputStream, (i == 1), kMapKeyFieldNumber, GPBDataTypeBool);
10055      WriteDictUInt32Field(outputStream, _values[i], kMapValueFieldNumber, valueDataType);
10056    }
10057  }
10058}
10059
10060- (void)addEntriesFromDictionary:(GPBBoolUInt32Dictionary *)otherDictionary {
10061  if (otherDictionary) {
10062    for (int i = 0; i < 2; ++i) {
10063      if (otherDictionary->_valueSet[i]) {
10064        _valueSet[i] = YES;
10065        _values[i] = otherDictionary->_values[i];
10066      }
10067    }
10068    if (_autocreator) {
10069      GPBAutocreatedDictionaryModified(_autocreator, self);
10070    }
10071  }
10072}
10073
10074- (void)setUInt32:(uint32_t)value forKey:(BOOL)key {
10075  int idx = (key ? 1 : 0);
10076  _values[idx] = value;
10077  _valueSet[idx] = YES;
10078  if (_autocreator) {
10079    GPBAutocreatedDictionaryModified(_autocreator, self);
10080  }
10081}
10082
10083- (void)removeUInt32ForKey:(BOOL)aKey {
10084  _valueSet[aKey ? 1 : 0] = NO;
10085}
10086
10087- (void)removeAll {
10088  _valueSet[0] = NO;
10089  _valueSet[1] = NO;
10090}
10091
10092@end
10093
10094//%PDDM-EXPAND DICTIONARY_BOOL_KEY_TO_POD_IMPL(Int32, int32_t)
10095// This block of code is generated, do not edit it directly.
10096
10097#pragma mark - Bool -> Int32
10098
10099@implementation GPBBoolInt32Dictionary {
10100 @package
10101  int32_t _values[2];
10102  BOOL _valueSet[2];
10103}
10104
10105- (instancetype)init {
10106  return [self initWithInt32s:NULL forKeys:NULL count:0];
10107}
10108
10109- (instancetype)initWithInt32s:(const int32_t [])values
10110                       forKeys:(const BOOL [])keys
10111                         count:(NSUInteger)count {
10112  self = [super init];
10113  if (self) {
10114    for (NSUInteger i = 0; i < count; ++i) {
10115      int idx = keys[i] ? 1 : 0;
10116      _values[idx] = values[i];
10117      _valueSet[idx] = YES;
10118    }
10119  }
10120  return self;
10121}
10122
10123- (instancetype)initWithDictionary:(GPBBoolInt32Dictionary *)dictionary {
10124  self = [self initWithInt32s:NULL forKeys:NULL count:0];
10125  if (self) {
10126    if (dictionary) {
10127      for (int i = 0; i < 2; ++i) {
10128        if (dictionary->_valueSet[i]) {
10129          _values[i] = dictionary->_values[i];
10130          _valueSet[i] = YES;
10131        }
10132      }
10133    }
10134  }
10135  return self;
10136}
10137
10138- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
10139  return [self initWithInt32s:NULL forKeys:NULL count:0];
10140}
10141
10142#if !defined(NS_BLOCK_ASSERTIONS)
10143- (void)dealloc {
10144  NSAssert(!_autocreator,
10145           @"%@: Autocreator must be cleared before release, autocreator: %@",
10146           [self class], _autocreator);
10147  [super dealloc];
10148}
10149#endif  // !defined(NS_BLOCK_ASSERTIONS)
10150
10151- (instancetype)copyWithZone:(NSZone *)zone {
10152  return [[GPBBoolInt32Dictionary allocWithZone:zone] initWithDictionary:self];
10153}
10154
10155- (BOOL)isEqual:(id)other {
10156  if (self == other) {
10157    return YES;
10158  }
10159  if (![other isKindOfClass:[GPBBoolInt32Dictionary class]]) {
10160    return NO;
10161  }
10162  GPBBoolInt32Dictionary *otherDictionary = other;
10163  if ((_valueSet[0] != otherDictionary->_valueSet[0]) ||
10164      (_valueSet[1] != otherDictionary->_valueSet[1])) {
10165    return NO;
10166  }
10167  if ((_valueSet[0] && (_values[0] != otherDictionary->_values[0])) ||
10168      (_valueSet[1] && (_values[1] != otherDictionary->_values[1]))) {
10169    return NO;
10170  }
10171  return YES;
10172}
10173
10174- (NSUInteger)hash {
10175  return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0);
10176}
10177
10178- (NSString *)description {
10179  NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> {", [self class], self];
10180  if (_valueSet[0]) {
10181    [result appendFormat:@"NO: %d", _values[0]];
10182  }
10183  if (_valueSet[1]) {
10184    [result appendFormat:@"YES: %d", _values[1]];
10185  }
10186  [result appendString:@" }"];
10187  return result;
10188}
10189
10190- (NSUInteger)count {
10191  return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0);
10192}
10193
10194- (BOOL)getInt32:(int32_t *)value forKey:(BOOL)key {
10195  int idx = (key ? 1 : 0);
10196  if (_valueSet[idx]) {
10197    if (value) {
10198      *value = _values[idx];
10199    }
10200    return YES;
10201  }
10202  return NO;
10203}
10204
10205- (void)setGPBGenericValue:(GPBGenericValue *)value
10206     forGPBGenericValueKey:(GPBGenericValue *)key {
10207  int idx = (key->valueBool ? 1 : 0);
10208  _values[idx] = value->valueInt32;
10209  _valueSet[idx] = YES;
10210}
10211
10212- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
10213  if (_valueSet[0]) {
10214    block(@"false", [NSString stringWithFormat:@"%d", _values[0]]);
10215  }
10216  if (_valueSet[1]) {
10217    block(@"true", [NSString stringWithFormat:@"%d", _values[1]]);
10218  }
10219}
10220
10221- (void)enumerateKeysAndInt32sUsingBlock:
10222    (void (NS_NOESCAPE ^)(BOOL key, int32_t value, BOOL *stop))block {
10223  BOOL stop = NO;
10224  if (_valueSet[0]) {
10225    block(NO, _values[0], &stop);
10226  }
10227  if (!stop && _valueSet[1]) {
10228    block(YES, _values[1], &stop);
10229  }
10230}
10231
10232- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
10233  GPBDataType valueDataType = GPBGetFieldDataType(field);
10234  NSUInteger count = 0;
10235  size_t result = 0;
10236  for (int i = 0; i < 2; ++i) {
10237    if (_valueSet[i]) {
10238      ++count;
10239      size_t msgSize = ComputeDictBoolFieldSize((i == 1), kMapKeyFieldNumber, GPBDataTypeBool);
10240      msgSize += ComputeDictInt32FieldSize(_values[i], kMapValueFieldNumber, valueDataType);
10241      result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
10242    }
10243  }
10244  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
10245  result += tagSize * count;
10246  return result;
10247}
10248
10249- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
10250                         asField:(GPBFieldDescriptor *)field {
10251  GPBDataType valueDataType = GPBGetFieldDataType(field);
10252  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
10253  for (int i = 0; i < 2; ++i) {
10254    if (_valueSet[i]) {
10255      // Write the tag.
10256      [outputStream writeInt32NoTag:tag];
10257      // Write the size of the message.
10258      size_t msgSize = ComputeDictBoolFieldSize((i == 1), kMapKeyFieldNumber, GPBDataTypeBool);
10259      msgSize += ComputeDictInt32FieldSize(_values[i], kMapValueFieldNumber, valueDataType);
10260      [outputStream writeInt32NoTag:(int32_t)msgSize];
10261      // Write the fields.
10262      WriteDictBoolField(outputStream, (i == 1), kMapKeyFieldNumber, GPBDataTypeBool);
10263      WriteDictInt32Field(outputStream, _values[i], kMapValueFieldNumber, valueDataType);
10264    }
10265  }
10266}
10267
10268- (void)addEntriesFromDictionary:(GPBBoolInt32Dictionary *)otherDictionary {
10269  if (otherDictionary) {
10270    for (int i = 0; i < 2; ++i) {
10271      if (otherDictionary->_valueSet[i]) {
10272        _valueSet[i] = YES;
10273        _values[i] = otherDictionary->_values[i];
10274      }
10275    }
10276    if (_autocreator) {
10277      GPBAutocreatedDictionaryModified(_autocreator, self);
10278    }
10279  }
10280}
10281
10282- (void)setInt32:(int32_t)value forKey:(BOOL)key {
10283  int idx = (key ? 1 : 0);
10284  _values[idx] = value;
10285  _valueSet[idx] = YES;
10286  if (_autocreator) {
10287    GPBAutocreatedDictionaryModified(_autocreator, self);
10288  }
10289}
10290
10291- (void)removeInt32ForKey:(BOOL)aKey {
10292  _valueSet[aKey ? 1 : 0] = NO;
10293}
10294
10295- (void)removeAll {
10296  _valueSet[0] = NO;
10297  _valueSet[1] = NO;
10298}
10299
10300@end
10301
10302//%PDDM-EXPAND DICTIONARY_BOOL_KEY_TO_POD_IMPL(UInt64, uint64_t)
10303// This block of code is generated, do not edit it directly.
10304
10305#pragma mark - Bool -> UInt64
10306
10307@implementation GPBBoolUInt64Dictionary {
10308 @package
10309  uint64_t _values[2];
10310  BOOL _valueSet[2];
10311}
10312
10313- (instancetype)init {
10314  return [self initWithUInt64s:NULL forKeys:NULL count:0];
10315}
10316
10317- (instancetype)initWithUInt64s:(const uint64_t [])values
10318                        forKeys:(const BOOL [])keys
10319                          count:(NSUInteger)count {
10320  self = [super init];
10321  if (self) {
10322    for (NSUInteger i = 0; i < count; ++i) {
10323      int idx = keys[i] ? 1 : 0;
10324      _values[idx] = values[i];
10325      _valueSet[idx] = YES;
10326    }
10327  }
10328  return self;
10329}
10330
10331- (instancetype)initWithDictionary:(GPBBoolUInt64Dictionary *)dictionary {
10332  self = [self initWithUInt64s:NULL forKeys:NULL count:0];
10333  if (self) {
10334    if (dictionary) {
10335      for (int i = 0; i < 2; ++i) {
10336        if (dictionary->_valueSet[i]) {
10337          _values[i] = dictionary->_values[i];
10338          _valueSet[i] = YES;
10339        }
10340      }
10341    }
10342  }
10343  return self;
10344}
10345
10346- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
10347  return [self initWithUInt64s:NULL forKeys:NULL count:0];
10348}
10349
10350#if !defined(NS_BLOCK_ASSERTIONS)
10351- (void)dealloc {
10352  NSAssert(!_autocreator,
10353           @"%@: Autocreator must be cleared before release, autocreator: %@",
10354           [self class], _autocreator);
10355  [super dealloc];
10356}
10357#endif  // !defined(NS_BLOCK_ASSERTIONS)
10358
10359- (instancetype)copyWithZone:(NSZone *)zone {
10360  return [[GPBBoolUInt64Dictionary allocWithZone:zone] initWithDictionary:self];
10361}
10362
10363- (BOOL)isEqual:(id)other {
10364  if (self == other) {
10365    return YES;
10366  }
10367  if (![other isKindOfClass:[GPBBoolUInt64Dictionary class]]) {
10368    return NO;
10369  }
10370  GPBBoolUInt64Dictionary *otherDictionary = other;
10371  if ((_valueSet[0] != otherDictionary->_valueSet[0]) ||
10372      (_valueSet[1] != otherDictionary->_valueSet[1])) {
10373    return NO;
10374  }
10375  if ((_valueSet[0] && (_values[0] != otherDictionary->_values[0])) ||
10376      (_valueSet[1] && (_values[1] != otherDictionary->_values[1]))) {
10377    return NO;
10378  }
10379  return YES;
10380}
10381
10382- (NSUInteger)hash {
10383  return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0);
10384}
10385
10386- (NSString *)description {
10387  NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> {", [self class], self];
10388  if (_valueSet[0]) {
10389    [result appendFormat:@"NO: %llu", _values[0]];
10390  }
10391  if (_valueSet[1]) {
10392    [result appendFormat:@"YES: %llu", _values[1]];
10393  }
10394  [result appendString:@" }"];
10395  return result;
10396}
10397
10398- (NSUInteger)count {
10399  return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0);
10400}
10401
10402- (BOOL)getUInt64:(uint64_t *)value forKey:(BOOL)key {
10403  int idx = (key ? 1 : 0);
10404  if (_valueSet[idx]) {
10405    if (value) {
10406      *value = _values[idx];
10407    }
10408    return YES;
10409  }
10410  return NO;
10411}
10412
10413- (void)setGPBGenericValue:(GPBGenericValue *)value
10414     forGPBGenericValueKey:(GPBGenericValue *)key {
10415  int idx = (key->valueBool ? 1 : 0);
10416  _values[idx] = value->valueUInt64;
10417  _valueSet[idx] = YES;
10418}
10419
10420- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
10421  if (_valueSet[0]) {
10422    block(@"false", [NSString stringWithFormat:@"%llu", _values[0]]);
10423  }
10424  if (_valueSet[1]) {
10425    block(@"true", [NSString stringWithFormat:@"%llu", _values[1]]);
10426  }
10427}
10428
10429- (void)enumerateKeysAndUInt64sUsingBlock:
10430    (void (NS_NOESCAPE ^)(BOOL key, uint64_t value, BOOL *stop))block {
10431  BOOL stop = NO;
10432  if (_valueSet[0]) {
10433    block(NO, _values[0], &stop);
10434  }
10435  if (!stop && _valueSet[1]) {
10436    block(YES, _values[1], &stop);
10437  }
10438}
10439
10440- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
10441  GPBDataType valueDataType = GPBGetFieldDataType(field);
10442  NSUInteger count = 0;
10443  size_t result = 0;
10444  for (int i = 0; i < 2; ++i) {
10445    if (_valueSet[i]) {
10446      ++count;
10447      size_t msgSize = ComputeDictBoolFieldSize((i == 1), kMapKeyFieldNumber, GPBDataTypeBool);
10448      msgSize += ComputeDictUInt64FieldSize(_values[i], kMapValueFieldNumber, valueDataType);
10449      result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
10450    }
10451  }
10452  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
10453  result += tagSize * count;
10454  return result;
10455}
10456
10457- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
10458                         asField:(GPBFieldDescriptor *)field {
10459  GPBDataType valueDataType = GPBGetFieldDataType(field);
10460  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
10461  for (int i = 0; i < 2; ++i) {
10462    if (_valueSet[i]) {
10463      // Write the tag.
10464      [outputStream writeInt32NoTag:tag];
10465      // Write the size of the message.
10466      size_t msgSize = ComputeDictBoolFieldSize((i == 1), kMapKeyFieldNumber, GPBDataTypeBool);
10467      msgSize += ComputeDictUInt64FieldSize(_values[i], kMapValueFieldNumber, valueDataType);
10468      [outputStream writeInt32NoTag:(int32_t)msgSize];
10469      // Write the fields.
10470      WriteDictBoolField(outputStream, (i == 1), kMapKeyFieldNumber, GPBDataTypeBool);
10471      WriteDictUInt64Field(outputStream, _values[i], kMapValueFieldNumber, valueDataType);
10472    }
10473  }
10474}
10475
10476- (void)addEntriesFromDictionary:(GPBBoolUInt64Dictionary *)otherDictionary {
10477  if (otherDictionary) {
10478    for (int i = 0; i < 2; ++i) {
10479      if (otherDictionary->_valueSet[i]) {
10480        _valueSet[i] = YES;
10481        _values[i] = otherDictionary->_values[i];
10482      }
10483    }
10484    if (_autocreator) {
10485      GPBAutocreatedDictionaryModified(_autocreator, self);
10486    }
10487  }
10488}
10489
10490- (void)setUInt64:(uint64_t)value forKey:(BOOL)key {
10491  int idx = (key ? 1 : 0);
10492  _values[idx] = value;
10493  _valueSet[idx] = YES;
10494  if (_autocreator) {
10495    GPBAutocreatedDictionaryModified(_autocreator, self);
10496  }
10497}
10498
10499- (void)removeUInt64ForKey:(BOOL)aKey {
10500  _valueSet[aKey ? 1 : 0] = NO;
10501}
10502
10503- (void)removeAll {
10504  _valueSet[0] = NO;
10505  _valueSet[1] = NO;
10506}
10507
10508@end
10509
10510//%PDDM-EXPAND DICTIONARY_BOOL_KEY_TO_POD_IMPL(Int64, int64_t)
10511// This block of code is generated, do not edit it directly.
10512
10513#pragma mark - Bool -> Int64
10514
10515@implementation GPBBoolInt64Dictionary {
10516 @package
10517  int64_t _values[2];
10518  BOOL _valueSet[2];
10519}
10520
10521- (instancetype)init {
10522  return [self initWithInt64s:NULL forKeys:NULL count:0];
10523}
10524
10525- (instancetype)initWithInt64s:(const int64_t [])values
10526                       forKeys:(const BOOL [])keys
10527                         count:(NSUInteger)count {
10528  self = [super init];
10529  if (self) {
10530    for (NSUInteger i = 0; i < count; ++i) {
10531      int idx = keys[i] ? 1 : 0;
10532      _values[idx] = values[i];
10533      _valueSet[idx] = YES;
10534    }
10535  }
10536  return self;
10537}
10538
10539- (instancetype)initWithDictionary:(GPBBoolInt64Dictionary *)dictionary {
10540  self = [self initWithInt64s:NULL forKeys:NULL count:0];
10541  if (self) {
10542    if (dictionary) {
10543      for (int i = 0; i < 2; ++i) {
10544        if (dictionary->_valueSet[i]) {
10545          _values[i] = dictionary->_values[i];
10546          _valueSet[i] = YES;
10547        }
10548      }
10549    }
10550  }
10551  return self;
10552}
10553
10554- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
10555  return [self initWithInt64s:NULL forKeys:NULL count:0];
10556}
10557
10558#if !defined(NS_BLOCK_ASSERTIONS)
10559- (void)dealloc {
10560  NSAssert(!_autocreator,
10561           @"%@: Autocreator must be cleared before release, autocreator: %@",
10562           [self class], _autocreator);
10563  [super dealloc];
10564}
10565#endif  // !defined(NS_BLOCK_ASSERTIONS)
10566
10567- (instancetype)copyWithZone:(NSZone *)zone {
10568  return [[GPBBoolInt64Dictionary allocWithZone:zone] initWithDictionary:self];
10569}
10570
10571- (BOOL)isEqual:(id)other {
10572  if (self == other) {
10573    return YES;
10574  }
10575  if (![other isKindOfClass:[GPBBoolInt64Dictionary class]]) {
10576    return NO;
10577  }
10578  GPBBoolInt64Dictionary *otherDictionary = other;
10579  if ((_valueSet[0] != otherDictionary->_valueSet[0]) ||
10580      (_valueSet[1] != otherDictionary->_valueSet[1])) {
10581    return NO;
10582  }
10583  if ((_valueSet[0] && (_values[0] != otherDictionary->_values[0])) ||
10584      (_valueSet[1] && (_values[1] != otherDictionary->_values[1]))) {
10585    return NO;
10586  }
10587  return YES;
10588}
10589
10590- (NSUInteger)hash {
10591  return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0);
10592}
10593
10594- (NSString *)description {
10595  NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> {", [self class], self];
10596  if (_valueSet[0]) {
10597    [result appendFormat:@"NO: %lld", _values[0]];
10598  }
10599  if (_valueSet[1]) {
10600    [result appendFormat:@"YES: %lld", _values[1]];
10601  }
10602  [result appendString:@" }"];
10603  return result;
10604}
10605
10606- (NSUInteger)count {
10607  return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0);
10608}
10609
10610- (BOOL)getInt64:(int64_t *)value forKey:(BOOL)key {
10611  int idx = (key ? 1 : 0);
10612  if (_valueSet[idx]) {
10613    if (value) {
10614      *value = _values[idx];
10615    }
10616    return YES;
10617  }
10618  return NO;
10619}
10620
10621- (void)setGPBGenericValue:(GPBGenericValue *)value
10622     forGPBGenericValueKey:(GPBGenericValue *)key {
10623  int idx = (key->valueBool ? 1 : 0);
10624  _values[idx] = value->valueInt64;
10625  _valueSet[idx] = YES;
10626}
10627
10628- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
10629  if (_valueSet[0]) {
10630    block(@"false", [NSString stringWithFormat:@"%lld", _values[0]]);
10631  }
10632  if (_valueSet[1]) {
10633    block(@"true", [NSString stringWithFormat:@"%lld", _values[1]]);
10634  }
10635}
10636
10637- (void)enumerateKeysAndInt64sUsingBlock:
10638    (void (NS_NOESCAPE ^)(BOOL key, int64_t value, BOOL *stop))block {
10639  BOOL stop = NO;
10640  if (_valueSet[0]) {
10641    block(NO, _values[0], &stop);
10642  }
10643  if (!stop && _valueSet[1]) {
10644    block(YES, _values[1], &stop);
10645  }
10646}
10647
10648- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
10649  GPBDataType valueDataType = GPBGetFieldDataType(field);
10650  NSUInteger count = 0;
10651  size_t result = 0;
10652  for (int i = 0; i < 2; ++i) {
10653    if (_valueSet[i]) {
10654      ++count;
10655      size_t msgSize = ComputeDictBoolFieldSize((i == 1), kMapKeyFieldNumber, GPBDataTypeBool);
10656      msgSize += ComputeDictInt64FieldSize(_values[i], kMapValueFieldNumber, valueDataType);
10657      result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
10658    }
10659  }
10660  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
10661  result += tagSize * count;
10662  return result;
10663}
10664
10665- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
10666                         asField:(GPBFieldDescriptor *)field {
10667  GPBDataType valueDataType = GPBGetFieldDataType(field);
10668  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
10669  for (int i = 0; i < 2; ++i) {
10670    if (_valueSet[i]) {
10671      // Write the tag.
10672      [outputStream writeInt32NoTag:tag];
10673      // Write the size of the message.
10674      size_t msgSize = ComputeDictBoolFieldSize((i == 1), kMapKeyFieldNumber, GPBDataTypeBool);
10675      msgSize += ComputeDictInt64FieldSize(_values[i], kMapValueFieldNumber, valueDataType);
10676      [outputStream writeInt32NoTag:(int32_t)msgSize];
10677      // Write the fields.
10678      WriteDictBoolField(outputStream, (i == 1), kMapKeyFieldNumber, GPBDataTypeBool);
10679      WriteDictInt64Field(outputStream, _values[i], kMapValueFieldNumber, valueDataType);
10680    }
10681  }
10682}
10683
10684- (void)addEntriesFromDictionary:(GPBBoolInt64Dictionary *)otherDictionary {
10685  if (otherDictionary) {
10686    for (int i = 0; i < 2; ++i) {
10687      if (otherDictionary->_valueSet[i]) {
10688        _valueSet[i] = YES;
10689        _values[i] = otherDictionary->_values[i];
10690      }
10691    }
10692    if (_autocreator) {
10693      GPBAutocreatedDictionaryModified(_autocreator, self);
10694    }
10695  }
10696}
10697
10698- (void)setInt64:(int64_t)value forKey:(BOOL)key {
10699  int idx = (key ? 1 : 0);
10700  _values[idx] = value;
10701  _valueSet[idx] = YES;
10702  if (_autocreator) {
10703    GPBAutocreatedDictionaryModified(_autocreator, self);
10704  }
10705}
10706
10707- (void)removeInt64ForKey:(BOOL)aKey {
10708  _valueSet[aKey ? 1 : 0] = NO;
10709}
10710
10711- (void)removeAll {
10712  _valueSet[0] = NO;
10713  _valueSet[1] = NO;
10714}
10715
10716@end
10717
10718//%PDDM-EXPAND DICTIONARY_BOOL_KEY_TO_POD_IMPL(Bool, BOOL)
10719// This block of code is generated, do not edit it directly.
10720
10721#pragma mark - Bool -> Bool
10722
10723@implementation GPBBoolBoolDictionary {
10724 @package
10725  BOOL _values[2];
10726  BOOL _valueSet[2];
10727}
10728
10729- (instancetype)init {
10730  return [self initWithBools:NULL forKeys:NULL count:0];
10731}
10732
10733- (instancetype)initWithBools:(const BOOL [])values
10734                      forKeys:(const BOOL [])keys
10735                        count:(NSUInteger)count {
10736  self = [super init];
10737  if (self) {
10738    for (NSUInteger i = 0; i < count; ++i) {
10739      int idx = keys[i] ? 1 : 0;
10740      _values[idx] = values[i];
10741      _valueSet[idx] = YES;
10742    }
10743  }
10744  return self;
10745}
10746
10747- (instancetype)initWithDictionary:(GPBBoolBoolDictionary *)dictionary {
10748  self = [self initWithBools:NULL forKeys:NULL count:0];
10749  if (self) {
10750    if (dictionary) {
10751      for (int i = 0; i < 2; ++i) {
10752        if (dictionary->_valueSet[i]) {
10753          _values[i] = dictionary->_values[i];
10754          _valueSet[i] = YES;
10755        }
10756      }
10757    }
10758  }
10759  return self;
10760}
10761
10762- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
10763  return [self initWithBools:NULL forKeys:NULL count:0];
10764}
10765
10766#if !defined(NS_BLOCK_ASSERTIONS)
10767- (void)dealloc {
10768  NSAssert(!_autocreator,
10769           @"%@: Autocreator must be cleared before release, autocreator: %@",
10770           [self class], _autocreator);
10771  [super dealloc];
10772}
10773#endif  // !defined(NS_BLOCK_ASSERTIONS)
10774
10775- (instancetype)copyWithZone:(NSZone *)zone {
10776  return [[GPBBoolBoolDictionary allocWithZone:zone] initWithDictionary:self];
10777}
10778
10779- (BOOL)isEqual:(id)other {
10780  if (self == other) {
10781    return YES;
10782  }
10783  if (![other isKindOfClass:[GPBBoolBoolDictionary class]]) {
10784    return NO;
10785  }
10786  GPBBoolBoolDictionary *otherDictionary = other;
10787  if ((_valueSet[0] != otherDictionary->_valueSet[0]) ||
10788      (_valueSet[1] != otherDictionary->_valueSet[1])) {
10789    return NO;
10790  }
10791  if ((_valueSet[0] && (_values[0] != otherDictionary->_values[0])) ||
10792      (_valueSet[1] && (_values[1] != otherDictionary->_values[1]))) {
10793    return NO;
10794  }
10795  return YES;
10796}
10797
10798- (NSUInteger)hash {
10799  return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0);
10800}
10801
10802- (NSString *)description {
10803  NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> {", [self class], self];
10804  if (_valueSet[0]) {
10805    [result appendFormat:@"NO: %d", _values[0]];
10806  }
10807  if (_valueSet[1]) {
10808    [result appendFormat:@"YES: %d", _values[1]];
10809  }
10810  [result appendString:@" }"];
10811  return result;
10812}
10813
10814- (NSUInteger)count {
10815  return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0);
10816}
10817
10818- (BOOL)getBool:(BOOL *)value forKey:(BOOL)key {
10819  int idx = (key ? 1 : 0);
10820  if (_valueSet[idx]) {
10821    if (value) {
10822      *value = _values[idx];
10823    }
10824    return YES;
10825  }
10826  return NO;
10827}
10828
10829- (void)setGPBGenericValue:(GPBGenericValue *)value
10830     forGPBGenericValueKey:(GPBGenericValue *)key {
10831  int idx = (key->valueBool ? 1 : 0);
10832  _values[idx] = value->valueBool;
10833  _valueSet[idx] = YES;
10834}
10835
10836- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
10837  if (_valueSet[0]) {
10838    block(@"false", (_values[0] ? @"true" : @"false"));
10839  }
10840  if (_valueSet[1]) {
10841    block(@"true", (_values[1] ? @"true" : @"false"));
10842  }
10843}
10844
10845- (void)enumerateKeysAndBoolsUsingBlock:
10846    (void (NS_NOESCAPE ^)(BOOL key, BOOL value, BOOL *stop))block {
10847  BOOL stop = NO;
10848  if (_valueSet[0]) {
10849    block(NO, _values[0], &stop);
10850  }
10851  if (!stop && _valueSet[1]) {
10852    block(YES, _values[1], &stop);
10853  }
10854}
10855
10856- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
10857  GPBDataType valueDataType = GPBGetFieldDataType(field);
10858  NSUInteger count = 0;
10859  size_t result = 0;
10860  for (int i = 0; i < 2; ++i) {
10861    if (_valueSet[i]) {
10862      ++count;
10863      size_t msgSize = ComputeDictBoolFieldSize((i == 1), kMapKeyFieldNumber, GPBDataTypeBool);
10864      msgSize += ComputeDictBoolFieldSize(_values[i], kMapValueFieldNumber, valueDataType);
10865      result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
10866    }
10867  }
10868  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
10869  result += tagSize * count;
10870  return result;
10871}
10872
10873- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
10874                         asField:(GPBFieldDescriptor *)field {
10875  GPBDataType valueDataType = GPBGetFieldDataType(field);
10876  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
10877  for (int i = 0; i < 2; ++i) {
10878    if (_valueSet[i]) {
10879      // Write the tag.
10880      [outputStream writeInt32NoTag:tag];
10881      // Write the size of the message.
10882      size_t msgSize = ComputeDictBoolFieldSize((i == 1), kMapKeyFieldNumber, GPBDataTypeBool);
10883      msgSize += ComputeDictBoolFieldSize(_values[i], kMapValueFieldNumber, valueDataType);
10884      [outputStream writeInt32NoTag:(int32_t)msgSize];
10885      // Write the fields.
10886      WriteDictBoolField(outputStream, (i == 1), kMapKeyFieldNumber, GPBDataTypeBool);
10887      WriteDictBoolField(outputStream, _values[i], kMapValueFieldNumber, valueDataType);
10888    }
10889  }
10890}
10891
10892- (void)addEntriesFromDictionary:(GPBBoolBoolDictionary *)otherDictionary {
10893  if (otherDictionary) {
10894    for (int i = 0; i < 2; ++i) {
10895      if (otherDictionary->_valueSet[i]) {
10896        _valueSet[i] = YES;
10897        _values[i] = otherDictionary->_values[i];
10898      }
10899    }
10900    if (_autocreator) {
10901      GPBAutocreatedDictionaryModified(_autocreator, self);
10902    }
10903  }
10904}
10905
10906- (void)setBool:(BOOL)value forKey:(BOOL)key {
10907  int idx = (key ? 1 : 0);
10908  _values[idx] = value;
10909  _valueSet[idx] = YES;
10910  if (_autocreator) {
10911    GPBAutocreatedDictionaryModified(_autocreator, self);
10912  }
10913}
10914
10915- (void)removeBoolForKey:(BOOL)aKey {
10916  _valueSet[aKey ? 1 : 0] = NO;
10917}
10918
10919- (void)removeAll {
10920  _valueSet[0] = NO;
10921  _valueSet[1] = NO;
10922}
10923
10924@end
10925
10926//%PDDM-EXPAND DICTIONARY_BOOL_KEY_TO_POD_IMPL(Float, float)
10927// This block of code is generated, do not edit it directly.
10928
10929#pragma mark - Bool -> Float
10930
10931@implementation GPBBoolFloatDictionary {
10932 @package
10933  float _values[2];
10934  BOOL _valueSet[2];
10935}
10936
10937- (instancetype)init {
10938  return [self initWithFloats:NULL forKeys:NULL count:0];
10939}
10940
10941- (instancetype)initWithFloats:(const float [])values
10942                       forKeys:(const BOOL [])keys
10943                         count:(NSUInteger)count {
10944  self = [super init];
10945  if (self) {
10946    for (NSUInteger i = 0; i < count; ++i) {
10947      int idx = keys[i] ? 1 : 0;
10948      _values[idx] = values[i];
10949      _valueSet[idx] = YES;
10950    }
10951  }
10952  return self;
10953}
10954
10955- (instancetype)initWithDictionary:(GPBBoolFloatDictionary *)dictionary {
10956  self = [self initWithFloats:NULL forKeys:NULL count:0];
10957  if (self) {
10958    if (dictionary) {
10959      for (int i = 0; i < 2; ++i) {
10960        if (dictionary->_valueSet[i]) {
10961          _values[i] = dictionary->_values[i];
10962          _valueSet[i] = YES;
10963        }
10964      }
10965    }
10966  }
10967  return self;
10968}
10969
10970- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
10971  return [self initWithFloats:NULL forKeys:NULL count:0];
10972}
10973
10974#if !defined(NS_BLOCK_ASSERTIONS)
10975- (void)dealloc {
10976  NSAssert(!_autocreator,
10977           @"%@: Autocreator must be cleared before release, autocreator: %@",
10978           [self class], _autocreator);
10979  [super dealloc];
10980}
10981#endif  // !defined(NS_BLOCK_ASSERTIONS)
10982
10983- (instancetype)copyWithZone:(NSZone *)zone {
10984  return [[GPBBoolFloatDictionary allocWithZone:zone] initWithDictionary:self];
10985}
10986
10987- (BOOL)isEqual:(id)other {
10988  if (self == other) {
10989    return YES;
10990  }
10991  if (![other isKindOfClass:[GPBBoolFloatDictionary class]]) {
10992    return NO;
10993  }
10994  GPBBoolFloatDictionary *otherDictionary = other;
10995  if ((_valueSet[0] != otherDictionary->_valueSet[0]) ||
10996      (_valueSet[1] != otherDictionary->_valueSet[1])) {
10997    return NO;
10998  }
10999  if ((_valueSet[0] && (_values[0] != otherDictionary->_values[0])) ||
11000      (_valueSet[1] && (_values[1] != otherDictionary->_values[1]))) {
11001    return NO;
11002  }
11003  return YES;
11004}
11005
11006- (NSUInteger)hash {
11007  return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0);
11008}
11009
11010- (NSString *)description {
11011  NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> {", [self class], self];
11012  if (_valueSet[0]) {
11013    [result appendFormat:@"NO: %f", _values[0]];
11014  }
11015  if (_valueSet[1]) {
11016    [result appendFormat:@"YES: %f", _values[1]];
11017  }
11018  [result appendString:@" }"];
11019  return result;
11020}
11021
11022- (NSUInteger)count {
11023  return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0);
11024}
11025
11026- (BOOL)getFloat:(float *)value forKey:(BOOL)key {
11027  int idx = (key ? 1 : 0);
11028  if (_valueSet[idx]) {
11029    if (value) {
11030      *value = _values[idx];
11031    }
11032    return YES;
11033  }
11034  return NO;
11035}
11036
11037- (void)setGPBGenericValue:(GPBGenericValue *)value
11038     forGPBGenericValueKey:(GPBGenericValue *)key {
11039  int idx = (key->valueBool ? 1 : 0);
11040  _values[idx] = value->valueFloat;
11041  _valueSet[idx] = YES;
11042}
11043
11044- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
11045  if (_valueSet[0]) {
11046    block(@"false", [NSString stringWithFormat:@"%.*g", FLT_DIG, _values[0]]);
11047  }
11048  if (_valueSet[1]) {
11049    block(@"true", [NSString stringWithFormat:@"%.*g", FLT_DIG, _values[1]]);
11050  }
11051}
11052
11053- (void)enumerateKeysAndFloatsUsingBlock:
11054    (void (NS_NOESCAPE ^)(BOOL key, float value, BOOL *stop))block {
11055  BOOL stop = NO;
11056  if (_valueSet[0]) {
11057    block(NO, _values[0], &stop);
11058  }
11059  if (!stop && _valueSet[1]) {
11060    block(YES, _values[1], &stop);
11061  }
11062}
11063
11064- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
11065  GPBDataType valueDataType = GPBGetFieldDataType(field);
11066  NSUInteger count = 0;
11067  size_t result = 0;
11068  for (int i = 0; i < 2; ++i) {
11069    if (_valueSet[i]) {
11070      ++count;
11071      size_t msgSize = ComputeDictBoolFieldSize((i == 1), kMapKeyFieldNumber, GPBDataTypeBool);
11072      msgSize += ComputeDictFloatFieldSize(_values[i], kMapValueFieldNumber, valueDataType);
11073      result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
11074    }
11075  }
11076  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
11077  result += tagSize * count;
11078  return result;
11079}
11080
11081- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
11082                         asField:(GPBFieldDescriptor *)field {
11083  GPBDataType valueDataType = GPBGetFieldDataType(field);
11084  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
11085  for (int i = 0; i < 2; ++i) {
11086    if (_valueSet[i]) {
11087      // Write the tag.
11088      [outputStream writeInt32NoTag:tag];
11089      // Write the size of the message.
11090      size_t msgSize = ComputeDictBoolFieldSize((i == 1), kMapKeyFieldNumber, GPBDataTypeBool);
11091      msgSize += ComputeDictFloatFieldSize(_values[i], kMapValueFieldNumber, valueDataType);
11092      [outputStream writeInt32NoTag:(int32_t)msgSize];
11093      // Write the fields.
11094      WriteDictBoolField(outputStream, (i == 1), kMapKeyFieldNumber, GPBDataTypeBool);
11095      WriteDictFloatField(outputStream, _values[i], kMapValueFieldNumber, valueDataType);
11096    }
11097  }
11098}
11099
11100- (void)addEntriesFromDictionary:(GPBBoolFloatDictionary *)otherDictionary {
11101  if (otherDictionary) {
11102    for (int i = 0; i < 2; ++i) {
11103      if (otherDictionary->_valueSet[i]) {
11104        _valueSet[i] = YES;
11105        _values[i] = otherDictionary->_values[i];
11106      }
11107    }
11108    if (_autocreator) {
11109      GPBAutocreatedDictionaryModified(_autocreator, self);
11110    }
11111  }
11112}
11113
11114- (void)setFloat:(float)value forKey:(BOOL)key {
11115  int idx = (key ? 1 : 0);
11116  _values[idx] = value;
11117  _valueSet[idx] = YES;
11118  if (_autocreator) {
11119    GPBAutocreatedDictionaryModified(_autocreator, self);
11120  }
11121}
11122
11123- (void)removeFloatForKey:(BOOL)aKey {
11124  _valueSet[aKey ? 1 : 0] = NO;
11125}
11126
11127- (void)removeAll {
11128  _valueSet[0] = NO;
11129  _valueSet[1] = NO;
11130}
11131
11132@end
11133
11134//%PDDM-EXPAND DICTIONARY_BOOL_KEY_TO_POD_IMPL(Double, double)
11135// This block of code is generated, do not edit it directly.
11136
11137#pragma mark - Bool -> Double
11138
11139@implementation GPBBoolDoubleDictionary {
11140 @package
11141  double _values[2];
11142  BOOL _valueSet[2];
11143}
11144
11145- (instancetype)init {
11146  return [self initWithDoubles:NULL forKeys:NULL count:0];
11147}
11148
11149- (instancetype)initWithDoubles:(const double [])values
11150                        forKeys:(const BOOL [])keys
11151                          count:(NSUInteger)count {
11152  self = [super init];
11153  if (self) {
11154    for (NSUInteger i = 0; i < count; ++i) {
11155      int idx = keys[i] ? 1 : 0;
11156      _values[idx] = values[i];
11157      _valueSet[idx] = YES;
11158    }
11159  }
11160  return self;
11161}
11162
11163- (instancetype)initWithDictionary:(GPBBoolDoubleDictionary *)dictionary {
11164  self = [self initWithDoubles:NULL forKeys:NULL count:0];
11165  if (self) {
11166    if (dictionary) {
11167      for (int i = 0; i < 2; ++i) {
11168        if (dictionary->_valueSet[i]) {
11169          _values[i] = dictionary->_values[i];
11170          _valueSet[i] = YES;
11171        }
11172      }
11173    }
11174  }
11175  return self;
11176}
11177
11178- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
11179  return [self initWithDoubles:NULL forKeys:NULL count:0];
11180}
11181
11182#if !defined(NS_BLOCK_ASSERTIONS)
11183- (void)dealloc {
11184  NSAssert(!_autocreator,
11185           @"%@: Autocreator must be cleared before release, autocreator: %@",
11186           [self class], _autocreator);
11187  [super dealloc];
11188}
11189#endif  // !defined(NS_BLOCK_ASSERTIONS)
11190
11191- (instancetype)copyWithZone:(NSZone *)zone {
11192  return [[GPBBoolDoubleDictionary allocWithZone:zone] initWithDictionary:self];
11193}
11194
11195- (BOOL)isEqual:(id)other {
11196  if (self == other) {
11197    return YES;
11198  }
11199  if (![other isKindOfClass:[GPBBoolDoubleDictionary class]]) {
11200    return NO;
11201  }
11202  GPBBoolDoubleDictionary *otherDictionary = other;
11203  if ((_valueSet[0] != otherDictionary->_valueSet[0]) ||
11204      (_valueSet[1] != otherDictionary->_valueSet[1])) {
11205    return NO;
11206  }
11207  if ((_valueSet[0] && (_values[0] != otherDictionary->_values[0])) ||
11208      (_valueSet[1] && (_values[1] != otherDictionary->_values[1]))) {
11209    return NO;
11210  }
11211  return YES;
11212}
11213
11214- (NSUInteger)hash {
11215  return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0);
11216}
11217
11218- (NSString *)description {
11219  NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> {", [self class], self];
11220  if (_valueSet[0]) {
11221    [result appendFormat:@"NO: %lf", _values[0]];
11222  }
11223  if (_valueSet[1]) {
11224    [result appendFormat:@"YES: %lf", _values[1]];
11225  }
11226  [result appendString:@" }"];
11227  return result;
11228}
11229
11230- (NSUInteger)count {
11231  return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0);
11232}
11233
11234- (BOOL)getDouble:(double *)value forKey:(BOOL)key {
11235  int idx = (key ? 1 : 0);
11236  if (_valueSet[idx]) {
11237    if (value) {
11238      *value = _values[idx];
11239    }
11240    return YES;
11241  }
11242  return NO;
11243}
11244
11245- (void)setGPBGenericValue:(GPBGenericValue *)value
11246     forGPBGenericValueKey:(GPBGenericValue *)key {
11247  int idx = (key->valueBool ? 1 : 0);
11248  _values[idx] = value->valueDouble;
11249  _valueSet[idx] = YES;
11250}
11251
11252- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
11253  if (_valueSet[0]) {
11254    block(@"false", [NSString stringWithFormat:@"%.*lg", DBL_DIG, _values[0]]);
11255  }
11256  if (_valueSet[1]) {
11257    block(@"true", [NSString stringWithFormat:@"%.*lg", DBL_DIG, _values[1]]);
11258  }
11259}
11260
11261- (void)enumerateKeysAndDoublesUsingBlock:
11262    (void (NS_NOESCAPE ^)(BOOL key, double value, BOOL *stop))block {
11263  BOOL stop = NO;
11264  if (_valueSet[0]) {
11265    block(NO, _values[0], &stop);
11266  }
11267  if (!stop && _valueSet[1]) {
11268    block(YES, _values[1], &stop);
11269  }
11270}
11271
11272- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
11273  GPBDataType valueDataType = GPBGetFieldDataType(field);
11274  NSUInteger count = 0;
11275  size_t result = 0;
11276  for (int i = 0; i < 2; ++i) {
11277    if (_valueSet[i]) {
11278      ++count;
11279      size_t msgSize = ComputeDictBoolFieldSize((i == 1), kMapKeyFieldNumber, GPBDataTypeBool);
11280      msgSize += ComputeDictDoubleFieldSize(_values[i], kMapValueFieldNumber, valueDataType);
11281      result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
11282    }
11283  }
11284  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
11285  result += tagSize * count;
11286  return result;
11287}
11288
11289- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
11290                         asField:(GPBFieldDescriptor *)field {
11291  GPBDataType valueDataType = GPBGetFieldDataType(field);
11292  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
11293  for (int i = 0; i < 2; ++i) {
11294    if (_valueSet[i]) {
11295      // Write the tag.
11296      [outputStream writeInt32NoTag:tag];
11297      // Write the size of the message.
11298      size_t msgSize = ComputeDictBoolFieldSize((i == 1), kMapKeyFieldNumber, GPBDataTypeBool);
11299      msgSize += ComputeDictDoubleFieldSize(_values[i], kMapValueFieldNumber, valueDataType);
11300      [outputStream writeInt32NoTag:(int32_t)msgSize];
11301      // Write the fields.
11302      WriteDictBoolField(outputStream, (i == 1), kMapKeyFieldNumber, GPBDataTypeBool);
11303      WriteDictDoubleField(outputStream, _values[i], kMapValueFieldNumber, valueDataType);
11304    }
11305  }
11306}
11307
11308- (void)addEntriesFromDictionary:(GPBBoolDoubleDictionary *)otherDictionary {
11309  if (otherDictionary) {
11310    for (int i = 0; i < 2; ++i) {
11311      if (otherDictionary->_valueSet[i]) {
11312        _valueSet[i] = YES;
11313        _values[i] = otherDictionary->_values[i];
11314      }
11315    }
11316    if (_autocreator) {
11317      GPBAutocreatedDictionaryModified(_autocreator, self);
11318    }
11319  }
11320}
11321
11322- (void)setDouble:(double)value forKey:(BOOL)key {
11323  int idx = (key ? 1 : 0);
11324  _values[idx] = value;
11325  _valueSet[idx] = YES;
11326  if (_autocreator) {
11327    GPBAutocreatedDictionaryModified(_autocreator, self);
11328  }
11329}
11330
11331- (void)removeDoubleForKey:(BOOL)aKey {
11332  _valueSet[aKey ? 1 : 0] = NO;
11333}
11334
11335- (void)removeAll {
11336  _valueSet[0] = NO;
11337  _valueSet[1] = NO;
11338}
11339
11340@end
11341
11342//%PDDM-EXPAND DICTIONARY_BOOL_KEY_TO_OBJECT_IMPL(Object, id)
11343// This block of code is generated, do not edit it directly.
11344
11345#pragma mark - Bool -> Object
11346
11347@implementation GPBBoolObjectDictionary {
11348 @package
11349  id _values[2];
11350}
11351
11352- (instancetype)init {
11353  return [self initWithObjects:NULL forKeys:NULL count:0];
11354}
11355
11356- (instancetype)initWithObjects:(const id [])objects
11357                        forKeys:(const BOOL [])keys
11358                          count:(NSUInteger)count {
11359  self = [super init];
11360  if (self) {
11361    for (NSUInteger i = 0; i < count; ++i) {
11362      if (!objects[i]) {
11363        [NSException raise:NSInvalidArgumentException
11364                    format:@"Attempting to add nil object to a Dictionary"];
11365      }
11366      int idx = keys[i] ? 1 : 0;
11367      [_values[idx] release];
11368      _values[idx] = (id)[objects[i] retain];
11369    }
11370  }
11371  return self;
11372}
11373
11374- (instancetype)initWithDictionary:(GPBBoolObjectDictionary *)dictionary {
11375  self = [self initWithObjects:NULL forKeys:NULL count:0];
11376  if (self) {
11377    if (dictionary) {
11378      _values[0] = [dictionary->_values[0] retain];
11379      _values[1] = [dictionary->_values[1] retain];
11380    }
11381  }
11382  return self;
11383}
11384
11385- (instancetype)initWithCapacity:(__unused NSUInteger)numItems {
11386  return [self initWithObjects:NULL forKeys:NULL count:0];
11387}
11388
11389- (void)dealloc {
11390  NSAssert(!_autocreator,
11391           @"%@: Autocreator must be cleared before release, autocreator: %@",
11392           [self class], _autocreator);
11393  [_values[0] release];
11394  [_values[1] release];
11395  [super dealloc];
11396}
11397
11398- (instancetype)copyWithZone:(NSZone *)zone {
11399  return [[GPBBoolObjectDictionary allocWithZone:zone] initWithDictionary:self];
11400}
11401
11402- (BOOL)isEqual:(id)other {
11403  if (self == other) {
11404    return YES;
11405  }
11406  if (![other isKindOfClass:[GPBBoolObjectDictionary class]]) {
11407    return NO;
11408  }
11409  GPBBoolObjectDictionary *otherDictionary = other;
11410  if (((_values[0] != nil) != (otherDictionary->_values[0] != nil)) ||
11411      ((_values[1] != nil) != (otherDictionary->_values[1] != nil))) {
11412    return NO;
11413  }
11414  if (((_values[0] != nil) && (![_values[0] isEqual:otherDictionary->_values[0]])) ||
11415      ((_values[1] != nil) && (![_values[1] isEqual:otherDictionary->_values[1]]))) {
11416    return NO;
11417  }
11418  return YES;
11419}
11420
11421- (NSUInteger)hash {
11422  return ((_values[0] != nil) ? 1 : 0) + ((_values[1] != nil) ? 1 : 0);
11423}
11424
11425- (NSString *)description {
11426  NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> {", [self class], self];
11427  if ((_values[0] != nil)) {
11428    [result appendFormat:@"NO: %@", _values[0]];
11429  }
11430  if ((_values[1] != nil)) {
11431    [result appendFormat:@"YES: %@", _values[1]];
11432  }
11433  [result appendString:@" }"];
11434  return result;
11435}
11436
11437- (NSUInteger)count {
11438  return ((_values[0] != nil) ? 1 : 0) + ((_values[1] != nil) ? 1 : 0);
11439}
11440
11441- (id)objectForKey:(BOOL)key {
11442  return _values[key ? 1 : 0];
11443}
11444
11445- (void)setGPBGenericValue:(GPBGenericValue *)value
11446     forGPBGenericValueKey:(GPBGenericValue *)key {
11447  int idx = (key->valueBool ? 1 : 0);
11448  [_values[idx] release];
11449  _values[idx] = [value->valueString retain];
11450}
11451
11452- (void)enumerateForTextFormat:(void (NS_NOESCAPE ^)(id keyObj, id valueObj))block {
11453  if (_values[0] != nil) {
11454    block(@"false", _values[0]);
11455  }
11456  if ((_values[1] != nil)) {
11457    block(@"true", _values[1]);
11458  }
11459}
11460
11461- (void)enumerateKeysAndObjectsUsingBlock:
11462    (void (NS_NOESCAPE ^)(BOOL key, id object, BOOL *stop))block {
11463  BOOL stop = NO;
11464  if (_values[0] != nil) {
11465    block(NO, _values[0], &stop);
11466  }
11467  if (!stop && (_values[1] != nil)) {
11468    block(YES, _values[1], &stop);
11469  }
11470}
11471
11472- (BOOL)isInitialized {
11473  if (_values[0] && ![_values[0] isInitialized]) {
11474    return NO;
11475  }
11476  if (_values[1] && ![_values[1] isInitialized]) {
11477    return NO;
11478  }
11479  return YES;
11480}
11481
11482- (instancetype)deepCopyWithZone:(NSZone *)zone {
11483  GPBBoolObjectDictionary *newDict =
11484      [[GPBBoolObjectDictionary alloc] init];
11485  for (int i = 0; i < 2; ++i) {
11486    if (_values[i] != nil) {
11487      newDict->_values[i] = [_values[i] copyWithZone:zone];
11488    }
11489  }
11490  return newDict;
11491}
11492
11493- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
11494  GPBDataType valueDataType = GPBGetFieldDataType(field);
11495  NSUInteger count = 0;
11496  size_t result = 0;
11497  for (int i = 0; i < 2; ++i) {
11498    if (_values[i] != nil) {
11499      ++count;
11500      size_t msgSize = ComputeDictBoolFieldSize((i == 1), kMapKeyFieldNumber, GPBDataTypeBool);
11501      msgSize += ComputeDictObjectFieldSize(_values[i], kMapValueFieldNumber, valueDataType);
11502      result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
11503    }
11504  }
11505  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
11506  result += tagSize * count;
11507  return result;
11508}
11509
11510- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
11511                         asField:(GPBFieldDescriptor *)field {
11512  GPBDataType valueDataType = GPBGetFieldDataType(field);
11513  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
11514  for (int i = 0; i < 2; ++i) {
11515    if (_values[i] != nil) {
11516      // Write the tag.
11517      [outputStream writeInt32NoTag:tag];
11518      // Write the size of the message.
11519      size_t msgSize = ComputeDictBoolFieldSize((i == 1), kMapKeyFieldNumber, GPBDataTypeBool);
11520      msgSize += ComputeDictObjectFieldSize(_values[i], kMapValueFieldNumber, valueDataType);
11521      [outputStream writeInt32NoTag:(int32_t)msgSize];
11522      // Write the fields.
11523      WriteDictBoolField(outputStream, (i == 1), kMapKeyFieldNumber, GPBDataTypeBool);
11524      WriteDictObjectField(outputStream, _values[i], kMapValueFieldNumber, valueDataType);
11525    }
11526  }
11527}
11528
11529- (void)addEntriesFromDictionary:(GPBBoolObjectDictionary *)otherDictionary {
11530  if (otherDictionary) {
11531    for (int i = 0; i < 2; ++i) {
11532      if (otherDictionary->_values[i] != nil) {
11533        [_values[i] release];
11534        _values[i] = [otherDictionary->_values[i] retain];
11535      }
11536    }
11537    if (_autocreator) {
11538      GPBAutocreatedDictionaryModified(_autocreator, self);
11539    }
11540  }
11541}
11542
11543- (void)setObject:(id)object forKey:(BOOL)key {
11544  if (!object) {
11545    [NSException raise:NSInvalidArgumentException
11546                format:@"Attempting to add nil object to a Dictionary"];
11547  }
11548  int idx = (key ? 1 : 0);
11549  [_values[idx] release];
11550  _values[idx] = [object retain];
11551  if (_autocreator) {
11552    GPBAutocreatedDictionaryModified(_autocreator, self);
11553  }
11554}
11555
11556- (void)removeObjectForKey:(BOOL)aKey {
11557  int idx = (aKey ? 1 : 0);
11558  [_values[idx] release];
11559  _values[idx] = nil;
11560}
11561
11562- (void)removeAll {
11563  for (int i = 0; i < 2; ++i) {
11564    [_values[i] release];
11565    _values[i] = nil;
11566  }
11567}
11568
11569@end
11570
11571//%PDDM-EXPAND-END (8 expansions)
11572
11573// clang-format on
11574
11575#pragma mark - Bool -> Enum
11576
11577@implementation GPBBoolEnumDictionary {
11578 @package
11579  GPBEnumValidationFunc _validationFunc;
11580  int32_t _values[2];
11581  BOOL _valueSet[2];
11582}
11583
11584@synthesize validationFunc = _validationFunc;
11585
11586- (instancetype)init {
11587  return [self initWithValidationFunction:NULL rawValues:NULL forKeys:NULL count:0];
11588}
11589
11590- (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func {
11591  return [self initWithValidationFunction:func rawValues:NULL forKeys:NULL count:0];
11592}
11593
11594- (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func
11595                                 rawValues:(const int32_t[])rawValues
11596                                   forKeys:(const BOOL[])keys
11597                                     count:(NSUInteger)count {
11598  self = [super init];
11599  if (self) {
11600    _validationFunc = (func != NULL ? func : DictDefault_IsValidValue);
11601    for (NSUInteger i = 0; i < count; ++i) {
11602      int idx = keys[i] ? 1 : 0;
11603      _values[idx] = rawValues[i];
11604      _valueSet[idx] = YES;
11605    }
11606  }
11607  return self;
11608}
11609
11610- (instancetype)initWithDictionary:(GPBBoolEnumDictionary *)dictionary {
11611  self = [self initWithValidationFunction:dictionary.validationFunc
11612                                rawValues:NULL
11613                                  forKeys:NULL
11614                                    count:0];
11615  if (self) {
11616    if (dictionary) {
11617      for (int i = 0; i < 2; ++i) {
11618        if (dictionary->_valueSet[i]) {
11619          _values[i] = dictionary->_values[i];
11620          _valueSet[i] = YES;
11621        }
11622      }
11623    }
11624  }
11625  return self;
11626}
11627
11628- (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func
11629                                  capacity:(__unused NSUInteger)numItems {
11630  return [self initWithValidationFunction:func rawValues:NULL forKeys:NULL count:0];
11631}
11632
11633#if !defined(NS_BLOCK_ASSERTIONS)
11634- (void)dealloc {
11635  NSAssert(!_autocreator, @"%@: Autocreator must be cleared before release, autocreator: %@",
11636           [self class], _autocreator);
11637  [super dealloc];
11638}
11639#endif  // !defined(NS_BLOCK_ASSERTIONS)
11640
11641- (instancetype)copyWithZone:(NSZone *)zone {
11642  return [[GPBBoolEnumDictionary allocWithZone:zone] initWithDictionary:self];
11643}
11644
11645- (BOOL)isEqual:(id)other {
11646  if (self == other) {
11647    return YES;
11648  }
11649  if (![other isKindOfClass:[GPBBoolEnumDictionary class]]) {
11650    return NO;
11651  }
11652  GPBBoolEnumDictionary *otherDictionary = other;
11653  if ((_valueSet[0] != otherDictionary->_valueSet[0]) ||
11654      (_valueSet[1] != otherDictionary->_valueSet[1])) {
11655    return NO;
11656  }
11657  if ((_valueSet[0] && (_values[0] != otherDictionary->_values[0])) ||
11658      (_valueSet[1] && (_values[1] != otherDictionary->_values[1]))) {
11659    return NO;
11660  }
11661  return YES;
11662}
11663
11664- (NSUInteger)hash {
11665  return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0);
11666}
11667
11668- (NSString *)description {
11669  NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> {", [self class], self];
11670  if (_valueSet[0]) {
11671    [result appendFormat:@"NO: %d", _values[0]];
11672  }
11673  if (_valueSet[1]) {
11674    [result appendFormat:@"YES: %d", _values[1]];
11675  }
11676  [result appendString:@" }"];
11677  return result;
11678}
11679
11680- (NSUInteger)count {
11681  return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0);
11682}
11683
11684- (BOOL)getEnum:(int32_t *)value forKey:(BOOL)key {
11685  int idx = (key ? 1 : 0);
11686  if (_valueSet[idx]) {
11687    if (value) {
11688      int32_t result = _values[idx];
11689      if (!_validationFunc(result)) {
11690        result = kGPBUnrecognizedEnumeratorValue;
11691      }
11692      *value = result;
11693    }
11694    return YES;
11695  }
11696  return NO;
11697}
11698
11699- (BOOL)getRawValue:(int32_t *)rawValue forKey:(BOOL)key {
11700  int idx = (key ? 1 : 0);
11701  if (_valueSet[idx]) {
11702    if (rawValue) {
11703      *rawValue = _values[idx];
11704    }
11705    return YES;
11706  }
11707  return NO;
11708}
11709
11710- (void)enumerateKeysAndRawValuesUsingBlock:(void(NS_NOESCAPE ^)(BOOL key, int32_t value,
11711                                                                 BOOL *stop))block {
11712  BOOL stop = NO;
11713  if (_valueSet[0]) {
11714    block(NO, _values[0], &stop);
11715  }
11716  if (!stop && _valueSet[1]) {
11717    block(YES, _values[1], &stop);
11718  }
11719}
11720
11721- (void)enumerateKeysAndEnumsUsingBlock:(void(NS_NOESCAPE ^)(BOOL key, int32_t rawValue,
11722                                                             BOOL *stop))block {
11723  BOOL stop = NO;
11724  GPBEnumValidationFunc func = _validationFunc;
11725  int32_t validatedValue;
11726  if (_valueSet[0]) {
11727    validatedValue = _values[0];
11728    if (!func(validatedValue)) {
11729      validatedValue = kGPBUnrecognizedEnumeratorValue;
11730    }
11731    block(NO, validatedValue, &stop);
11732  }
11733  if (!stop && _valueSet[1]) {
11734    validatedValue = _values[1];
11735    if (!func(validatedValue)) {
11736      validatedValue = kGPBUnrecognizedEnumeratorValue;
11737    }
11738    block(YES, validatedValue, &stop);
11739  }
11740}
11741
11742// clang-format off
11743
11744//%PDDM-EXPAND SERIAL_DATA_FOR_ENTRY_POD_Enum(Bool)
11745// This block of code is generated, do not edit it directly.
11746
11747- (NSData *)serializedDataForUnknownValue:(int32_t)value
11748                                   forKey:(GPBGenericValue *)key
11749                              keyDataType:(GPBDataType)keyDataType {
11750  size_t msgSize = ComputeDictBoolFieldSize(key->valueBool, kMapKeyFieldNumber, keyDataType);
11751  msgSize += ComputeDictEnumFieldSize(value, kMapValueFieldNumber, GPBDataTypeEnum);
11752  NSMutableData *data = [NSMutableData dataWithLength:msgSize];
11753  GPBCodedOutputStream *outputStream = [[GPBCodedOutputStream alloc] initWithData:data];
11754  WriteDictBoolField(outputStream, key->valueBool, kMapKeyFieldNumber, keyDataType);
11755  WriteDictEnumField(outputStream, value, kMapValueFieldNumber, GPBDataTypeEnum);
11756  [outputStream flush];
11757  [outputStream release];
11758  return data;
11759}
11760
11761//%PDDM-EXPAND-END SERIAL_DATA_FOR_ENTRY_POD_Enum(Bool)
11762
11763// clang-format on
11764
11765- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
11766  GPBDataType valueDataType = GPBGetFieldDataType(field);
11767  NSUInteger count = 0;
11768  size_t result = 0;
11769  for (int i = 0; i < 2; ++i) {
11770    if (_valueSet[i]) {
11771      ++count;
11772      size_t msgSize = ComputeDictBoolFieldSize((i == 1), kMapKeyFieldNumber, GPBDataTypeBool);
11773      msgSize += ComputeDictInt32FieldSize(_values[i], kMapValueFieldNumber, valueDataType);
11774      result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
11775    }
11776  }
11777  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
11778  result += tagSize * count;
11779  return result;
11780}
11781
11782- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
11783                         asField:(GPBFieldDescriptor *)field {
11784  GPBDataType valueDataType = GPBGetFieldDataType(field);
11785  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
11786  for (int i = 0; i < 2; ++i) {
11787    if (_valueSet[i]) {
11788      // Write the tag.
11789      [outputStream writeInt32NoTag:tag];
11790      // Write the size of the message.
11791      size_t msgSize = ComputeDictBoolFieldSize((i == 1), kMapKeyFieldNumber, GPBDataTypeBool);
11792      msgSize += ComputeDictInt32FieldSize(_values[i], kMapValueFieldNumber, valueDataType);
11793      [outputStream writeInt32NoTag:(int32_t)msgSize];
11794      // Write the fields.
11795      WriteDictBoolField(outputStream, (i == 1), kMapKeyFieldNumber, GPBDataTypeBool);
11796      WriteDictInt32Field(outputStream, _values[i], kMapValueFieldNumber, valueDataType);
11797    }
11798  }
11799}
11800
11801- (void)enumerateForTextFormat:(void(NS_NOESCAPE ^)(id keyObj, id valueObj))block {
11802  if (_valueSet[0]) {
11803    block(@"false", @(_values[0]));
11804  }
11805  if (_valueSet[1]) {
11806    block(@"true", @(_values[1]));
11807  }
11808}
11809
11810- (void)setGPBGenericValue:(GPBGenericValue *)value forGPBGenericValueKey:(GPBGenericValue *)key {
11811  int idx = (key->valueBool ? 1 : 0);
11812  _values[idx] = value->valueInt32;
11813  _valueSet[idx] = YES;
11814}
11815
11816- (void)addRawEntriesFromDictionary:(GPBBoolEnumDictionary *)otherDictionary {
11817  if (otherDictionary) {
11818    for (int i = 0; i < 2; ++i) {
11819      if (otherDictionary->_valueSet[i]) {
11820        _valueSet[i] = YES;
11821        _values[i] = otherDictionary->_values[i];
11822      }
11823    }
11824    if (_autocreator) {
11825      GPBAutocreatedDictionaryModified(_autocreator, self);
11826    }
11827  }
11828}
11829
11830- (void)setEnum:(int32_t)value forKey:(BOOL)key {
11831  if (!_validationFunc(value)) {
11832    [NSException raise:NSInvalidArgumentException
11833                format:@"GPBBoolEnumDictionary: Attempt to set an unknown enum value (%d)", value];
11834  }
11835  int idx = (key ? 1 : 0);
11836  _values[idx] = value;
11837  _valueSet[idx] = YES;
11838  if (_autocreator) {
11839    GPBAutocreatedDictionaryModified(_autocreator, self);
11840  }
11841}
11842
11843- (void)setRawValue:(int32_t)rawValue forKey:(BOOL)key {
11844  int idx = (key ? 1 : 0);
11845  _values[idx] = rawValue;
11846  _valueSet[idx] = YES;
11847  if (_autocreator) {
11848    GPBAutocreatedDictionaryModified(_autocreator, self);
11849  }
11850}
11851
11852- (void)removeEnumForKey:(BOOL)aKey {
11853  _valueSet[aKey ? 1 : 0] = NO;
11854}
11855
11856- (void)removeAll {
11857  _valueSet[0] = NO;
11858  _valueSet[1] = NO;
11859}
11860
11861@end
11862
11863#pragma mark - NSDictionary Subclass
11864
11865@implementation GPBAutocreatedDictionary {
11866  NSMutableDictionary *_dictionary;
11867}
11868
11869- (void)dealloc {
11870  NSAssert(!_autocreator, @"%@: Autocreator must be cleared before release, autocreator: %@",
11871           [self class], _autocreator);
11872  [_dictionary release];
11873  [super dealloc];
11874}
11875
11876#pragma mark Required NSDictionary overrides
11877
11878- (instancetype)initWithObjects:(const id[])objects
11879                        forKeys:(const id<NSCopying>[])keys
11880                          count:(NSUInteger)count {
11881  self = [super init];
11882  if (self) {
11883    _dictionary = [[NSMutableDictionary alloc] initWithObjects:objects forKeys:keys count:count];
11884  }
11885  return self;
11886}
11887
11888- (NSUInteger)count {
11889  return [_dictionary count];
11890}
11891
11892- (id)objectForKey:(id)aKey {
11893  return [_dictionary objectForKey:aKey];
11894}
11895
11896- (NSEnumerator *)keyEnumerator {
11897  if (_dictionary == nil) {
11898    _dictionary = [[NSMutableDictionary alloc] init];
11899  }
11900  return [_dictionary keyEnumerator];
11901}
11902
11903#pragma mark Required NSMutableDictionary overrides
11904
11905// Only need to call GPBAutocreatedDictionaryModified() when adding things
11906// since we only autocreate empty dictionaries.
11907
11908- (void)setObject:(id)anObject forKey:(id<NSCopying>)aKey {
11909  if (_dictionary == nil) {
11910    _dictionary = [[NSMutableDictionary alloc] init];
11911  }
11912  [_dictionary setObject:anObject forKey:aKey];
11913  if (_autocreator) {
11914    GPBAutocreatedDictionaryModified(_autocreator, self);
11915  }
11916}
11917
11918- (void)removeObjectForKey:(id)aKey {
11919  [_dictionary removeObjectForKey:aKey];
11920}
11921
11922#pragma mark Extra things hooked
11923
11924- (id)copyWithZone:(NSZone *)zone {
11925  if (_dictionary == nil) {
11926    return [[NSMutableDictionary allocWithZone:zone] init];
11927  }
11928  return [_dictionary copyWithZone:zone];
11929}
11930
11931- (id)mutableCopyWithZone:(NSZone *)zone {
11932  if (_dictionary == nil) {
11933    return [[NSMutableDictionary allocWithZone:zone] init];
11934  }
11935  return [_dictionary mutableCopyWithZone:zone];
11936}
11937
11938// Not really needed, but subscripting is likely common enough it doesn't hurt
11939// to ensure it goes directly to the real NSMutableDictionary.
11940- (id)objectForKeyedSubscript:(id)key {
11941  return [_dictionary objectForKeyedSubscript:key];
11942}
11943
11944// Not really needed, but subscripting is likely common enough it doesn't hurt
11945// to ensure it goes directly to the real NSMutableDictionary.
11946- (void)setObject:(id)obj forKeyedSubscript:(id<NSCopying>)key {
11947  if (_dictionary == nil) {
11948    _dictionary = [[NSMutableDictionary alloc] init];
11949  }
11950  [_dictionary setObject:obj forKeyedSubscript:key];
11951  if (_autocreator) {
11952    GPBAutocreatedDictionaryModified(_autocreator, self);
11953  }
11954}
11955
11956- (void)enumerateKeysAndObjectsUsingBlock:(void(NS_NOESCAPE ^)(id key, id obj, BOOL *stop))block {
11957  [_dictionary enumerateKeysAndObjectsUsingBlock:block];
11958}
11959
11960- (void)enumerateKeysAndObjectsWithOptions:(NSEnumerationOptions)opts
11961                                usingBlock:(void(NS_NOESCAPE ^)(id key, id obj, BOOL *stop))block {
11962  [_dictionary enumerateKeysAndObjectsWithOptions:opts usingBlock:block];
11963}
11964
11965@end
11966
11967#pragma clang diagnostic pop
11968