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