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 // Used to include code only visible to specific versions of the static 49 // analyzer. Useful for wrapping code that only exists to silence the analyzer. 50 // Determine the values you want to use for BEGIN_APPLE_BUILD_VERSION, 51 // END_APPLE_BUILD_VERSION using: 52 // xcrun clang -dM -E -x c /dev/null | grep __apple_build_version__ 53 // Example usage: 54 // #if GPB_STATIC_ANALYZER_ONLY(5621, 5623) ... #endif 55 #define GPB_STATIC_ANALYZER_ONLY(BEGIN_APPLE_BUILD_VERSION, END_APPLE_BUILD_VERSION) \ 56 (defined(__clang_analyzer__) && \ 57 (__apple_build_version__ >= BEGIN_APPLE_BUILD_VERSION && \ 58 __apple_build_version__ <= END_APPLE_BUILD_VERSION)) 59 60 enum { 61 kMapKeyFieldNumber = 1, 62 kMapValueFieldNumber = 2, 63 }; 64 65 static BOOL DictDefault_IsValidValue(int32_t value) { 66 // Anything but the bad value marker is allowed. 67 return (value != kGPBUnrecognizedEnumeratorValue); 68 } 69 70 //%PDDM-DEFINE SERIALIZE_SUPPORT_2_TYPE(VALUE_NAME, VALUE_TYPE, GPBDATATYPE_NAME1, GPBDATATYPE_NAME2) 71 //%static size_t ComputeDict##VALUE_NAME##FieldSize(VALUE_TYPE value, uint32_t fieldNum, GPBDataType dataType) { 72 //% if (dataType == GPBDataType##GPBDATATYPE_NAME1) { 73 //% return GPBCompute##GPBDATATYPE_NAME1##Size(fieldNum, value); 74 //% } else if (dataType == GPBDataType##GPBDATATYPE_NAME2) { 75 //% return GPBCompute##GPBDATATYPE_NAME2##Size(fieldNum, value); 76 //% } else { 77 //% NSCAssert(NO, @"Unexpected type %d", dataType); 78 //% return 0; 79 //% } 80 //%} 81 //% 82 //%static void WriteDict##VALUE_NAME##Field(GPBCodedOutputStream *stream, VALUE_TYPE value, uint32_t fieldNum, GPBDataType dataType) { 83 //% if (dataType == GPBDataType##GPBDATATYPE_NAME1) { 84 //% [stream write##GPBDATATYPE_NAME1##:fieldNum value:value]; 85 //% } else if (dataType == GPBDataType##GPBDATATYPE_NAME2) { 86 //% [stream write##GPBDATATYPE_NAME2##:fieldNum value:value]; 87 //% } else { 88 //% NSCAssert(NO, @"Unexpected type %d", dataType); 89 //% } 90 //%} 91 //% 92 //%PDDM-DEFINE SERIALIZE_SUPPORT_3_TYPE(VALUE_NAME, VALUE_TYPE, GPBDATATYPE_NAME1, GPBDATATYPE_NAME2, GPBDATATYPE_NAME3) 93 //%static size_t ComputeDict##VALUE_NAME##FieldSize(VALUE_TYPE value, uint32_t fieldNum, GPBDataType dataType) { 94 //% if (dataType == GPBDataType##GPBDATATYPE_NAME1) { 95 //% return GPBCompute##GPBDATATYPE_NAME1##Size(fieldNum, value); 96 //% } else if (dataType == GPBDataType##GPBDATATYPE_NAME2) { 97 //% return GPBCompute##GPBDATATYPE_NAME2##Size(fieldNum, value); 98 //% } else if (dataType == GPBDataType##GPBDATATYPE_NAME3) { 99 //% return GPBCompute##GPBDATATYPE_NAME3##Size(fieldNum, value); 100 //% } else { 101 //% NSCAssert(NO, @"Unexpected type %d", dataType); 102 //% return 0; 103 //% } 104 //%} 105 //% 106 //%static void WriteDict##VALUE_NAME##Field(GPBCodedOutputStream *stream, VALUE_TYPE value, uint32_t fieldNum, GPBDataType dataType) { 107 //% if (dataType == GPBDataType##GPBDATATYPE_NAME1) { 108 //% [stream write##GPBDATATYPE_NAME1##:fieldNum value:value]; 109 //% } else if (dataType == GPBDataType##GPBDATATYPE_NAME2) { 110 //% [stream write##GPBDATATYPE_NAME2##:fieldNum value:value]; 111 //% } else if (dataType == GPBDataType##GPBDATATYPE_NAME3) { 112 //% [stream write##GPBDATATYPE_NAME3##:fieldNum value:value]; 113 //% } else { 114 //% NSCAssert(NO, @"Unexpected type %d", dataType); 115 //% } 116 //%} 117 //% 118 //%PDDM-DEFINE SIMPLE_SERIALIZE_SUPPORT(VALUE_NAME, VALUE_TYPE, VisP) 119 //%static size_t ComputeDict##VALUE_NAME##FieldSize(VALUE_TYPE VisP##value, uint32_t fieldNum, GPBDataType dataType) { 120 //% NSCAssert(dataType == GPBDataType##VALUE_NAME, @"bad type: %d", dataType); 121 //% #pragma unused(dataType) // For when asserts are off in release. 122 //% return GPBCompute##VALUE_NAME##Size(fieldNum, value); 123 //%} 124 //% 125 //%static void WriteDict##VALUE_NAME##Field(GPBCodedOutputStream *stream, 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 //% [stream write##VALUE_NAME##:fieldNum value:value]; 129 //%} 130 //% 131 //%PDDM-DEFINE SERIALIZE_SUPPORT_HELPERS() 132 //%SERIALIZE_SUPPORT_3_TYPE(Int32, int32_t, Int32, SInt32, SFixed32) 133 //%SERIALIZE_SUPPORT_2_TYPE(UInt32, uint32_t, UInt32, Fixed32) 134 //%SERIALIZE_SUPPORT_3_TYPE(Int64, int64_t, Int64, SInt64, SFixed64) 135 //%SERIALIZE_SUPPORT_2_TYPE(UInt64, uint64_t, UInt64, Fixed64) 136 //%SIMPLE_SERIALIZE_SUPPORT(Bool, BOOL, ) 137 //%SIMPLE_SERIALIZE_SUPPORT(Enum, int32_t, ) 138 //%SIMPLE_SERIALIZE_SUPPORT(Float, float, ) 139 //%SIMPLE_SERIALIZE_SUPPORT(Double, double, ) 140 //%SIMPLE_SERIALIZE_SUPPORT(String, NSString, *) 141 //%SERIALIZE_SUPPORT_3_TYPE(Object, id, Message, String, Bytes) 142 //%PDDM-EXPAND SERIALIZE_SUPPORT_HELPERS() 143 // This block of code is generated, do not edit it directly. 144 145 static size_t ComputeDictInt32FieldSize(int32_t value, uint32_t fieldNum, GPBDataType dataType) { 146 if (dataType == GPBDataTypeInt32) { 147 return GPBComputeInt32Size(fieldNum, value); 148 } else if (dataType == GPBDataTypeSInt32) { 149 return GPBComputeSInt32Size(fieldNum, value); 150 } else if (dataType == GPBDataTypeSFixed32) { 151 return GPBComputeSFixed32Size(fieldNum, value); 152 } else { 153 NSCAssert(NO, @"Unexpected type %d", dataType); 154 return 0; 155 } 156 } 157 158 static void WriteDictInt32Field(GPBCodedOutputStream *stream, int32_t value, uint32_t fieldNum, GPBDataType dataType) { 159 if (dataType == GPBDataTypeInt32) { 160 [stream writeInt32:fieldNum value:value]; 161 } else if (dataType == GPBDataTypeSInt32) { 162 [stream writeSInt32:fieldNum value:value]; 163 } else if (dataType == GPBDataTypeSFixed32) { 164 [stream writeSFixed32:fieldNum value:value]; 165 } else { 166 NSCAssert(NO, @"Unexpected type %d", dataType); 167 } 168 } 169 170 static size_t ComputeDictUInt32FieldSize(uint32_t value, uint32_t fieldNum, GPBDataType dataType) { 171 if (dataType == GPBDataTypeUInt32) { 172 return GPBComputeUInt32Size(fieldNum, value); 173 } else if (dataType == GPBDataTypeFixed32) { 174 return GPBComputeFixed32Size(fieldNum, value); 175 } else { 176 NSCAssert(NO, @"Unexpected type %d", dataType); 177 return 0; 178 } 179 } 180 181 static void WriteDictUInt32Field(GPBCodedOutputStream *stream, uint32_t value, uint32_t fieldNum, GPBDataType dataType) { 182 if (dataType == GPBDataTypeUInt32) { 183 [stream writeUInt32:fieldNum value:value]; 184 } else if (dataType == GPBDataTypeFixed32) { 185 [stream writeFixed32:fieldNum value:value]; 186 } else { 187 NSCAssert(NO, @"Unexpected type %d", dataType); 188 } 189 } 190 191 static size_t ComputeDictInt64FieldSize(int64_t value, uint32_t fieldNum, GPBDataType dataType) { 192 if (dataType == GPBDataTypeInt64) { 193 return GPBComputeInt64Size(fieldNum, value); 194 } else if (dataType == GPBDataTypeSInt64) { 195 return GPBComputeSInt64Size(fieldNum, value); 196 } else if (dataType == GPBDataTypeSFixed64) { 197 return GPBComputeSFixed64Size(fieldNum, value); 198 } else { 199 NSCAssert(NO, @"Unexpected type %d", dataType); 200 return 0; 201 } 202 } 203 204 static void WriteDictInt64Field(GPBCodedOutputStream *stream, int64_t value, uint32_t fieldNum, GPBDataType dataType) { 205 if (dataType == GPBDataTypeInt64) { 206 [stream writeInt64:fieldNum value:value]; 207 } else if (dataType == GPBDataTypeSInt64) { 208 [stream writeSInt64:fieldNum value:value]; 209 } else if (dataType == GPBDataTypeSFixed64) { 210 [stream writeSFixed64:fieldNum value:value]; 211 } else { 212 NSCAssert(NO, @"Unexpected type %d", dataType); 213 } 214 } 215 216 static size_t ComputeDictUInt64FieldSize(uint64_t value, uint32_t fieldNum, GPBDataType dataType) { 217 if (dataType == GPBDataTypeUInt64) { 218 return GPBComputeUInt64Size(fieldNum, value); 219 } else if (dataType == GPBDataTypeFixed64) { 220 return GPBComputeFixed64Size(fieldNum, value); 221 } else { 222 NSCAssert(NO, @"Unexpected type %d", dataType); 223 return 0; 224 } 225 } 226 227 static void WriteDictUInt64Field(GPBCodedOutputStream *stream, uint64_t value, uint32_t fieldNum, GPBDataType dataType) { 228 if (dataType == GPBDataTypeUInt64) { 229 [stream writeUInt64:fieldNum value:value]; 230 } else if (dataType == GPBDataTypeFixed64) { 231 [stream writeFixed64:fieldNum value:value]; 232 } else { 233 NSCAssert(NO, @"Unexpected type %d", dataType); 234 } 235 } 236 237 static size_t ComputeDictBoolFieldSize(BOOL value, uint32_t fieldNum, GPBDataType dataType) { 238 NSCAssert(dataType == GPBDataTypeBool, @"bad type: %d", dataType); 239 #pragma unused(dataType) // For when asserts are off in release. 240 return GPBComputeBoolSize(fieldNum, value); 241 } 242 243 static void WriteDictBoolField(GPBCodedOutputStream *stream, 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 [stream writeBool:fieldNum value:value]; 247 } 248 249 static size_t ComputeDictEnumFieldSize(int32_t value, uint32_t fieldNum, GPBDataType dataType) { 250 NSCAssert(dataType == GPBDataTypeEnum, @"bad type: %d", dataType); 251 #pragma unused(dataType) // For when asserts are off in release. 252 return GPBComputeEnumSize(fieldNum, value); 253 } 254 255 static void WriteDictEnumField(GPBCodedOutputStream *stream, 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 [stream writeEnum:fieldNum value:value]; 259 } 260 261 static size_t ComputeDictFloatFieldSize(float value, uint32_t fieldNum, GPBDataType dataType) { 262 NSCAssert(dataType == GPBDataTypeFloat, @"bad type: %d", dataType); 263 #pragma unused(dataType) // For when asserts are off in release. 264 return GPBComputeFloatSize(fieldNum, value); 265 } 266 267 static void WriteDictFloatField(GPBCodedOutputStream *stream, 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 [stream writeFloat:fieldNum value:value]; 271 } 272 273 static size_t ComputeDictDoubleFieldSize(double value, uint32_t fieldNum, GPBDataType dataType) { 274 NSCAssert(dataType == GPBDataTypeDouble, @"bad type: %d", dataType); 275 #pragma unused(dataType) // For when asserts are off in release. 276 return GPBComputeDoubleSize(fieldNum, value); 277 } 278 279 static void WriteDictDoubleField(GPBCodedOutputStream *stream, 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 [stream writeDouble:fieldNum value:value]; 283 } 284 285 static size_t ComputeDictStringFieldSize(NSString *value, uint32_t fieldNum, GPBDataType dataType) { 286 NSCAssert(dataType == GPBDataTypeString, @"bad type: %d", dataType); 287 #pragma unused(dataType) // For when asserts are off in release. 288 return GPBComputeStringSize(fieldNum, value); 289 } 290 291 static void WriteDictStringField(GPBCodedOutputStream *stream, 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 [stream writeString:fieldNum value:value]; 295 } 296 297 static size_t ComputeDictObjectFieldSize(id value, uint32_t fieldNum, GPBDataType dataType) { 298 if (dataType == GPBDataTypeMessage) { 299 return GPBComputeMessageSize(fieldNum, value); 300 } else if (dataType == GPBDataTypeString) { 301 return GPBComputeStringSize(fieldNum, value); 302 } else if (dataType == GPBDataTypeBytes) { 303 return GPBComputeBytesSize(fieldNum, value); 304 } else { 305 NSCAssert(NO, @"Unexpected type %d", dataType); 306 return 0; 307 } 308 } 309 310 static void WriteDictObjectField(GPBCodedOutputStream *stream, id value, uint32_t fieldNum, GPBDataType dataType) { 311 if (dataType == GPBDataTypeMessage) { 312 [stream writeMessage:fieldNum value:value]; 313 } else if (dataType == GPBDataTypeString) { 314 [stream writeString:fieldNum value:value]; 315 } else if (dataType == GPBDataTypeBytes) { 316 [stream writeBytes:fieldNum value:value]; 317 } else { 318 NSCAssert(NO, @"Unexpected type %d", dataType); 319 } 320 } 321 322 //%PDDM-EXPAND-END SERIALIZE_SUPPORT_HELPERS() 323 324 size_t GPBDictionaryComputeSizeInternalHelper(NSDictionary *dict, GPBFieldDescriptor *field) { 325 GPBDataType mapValueType = GPBGetFieldDataType(field); 326 __block size_t result = 0; 327 [dict enumerateKeysAndObjectsUsingBlock:^(NSString *key, id obj, BOOL *stop) { 328 #pragma unused(stop) 329 size_t msgSize = GPBComputeStringSize(kMapKeyFieldNumber, key); 330 msgSize += ComputeDictObjectFieldSize(obj, kMapValueFieldNumber, mapValueType); 331 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 332 }]; 333 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 334 result += tagSize * dict.count; 335 return result; 336 } 337 338 void GPBDictionaryWriteToStreamInternalHelper(GPBCodedOutputStream *outputStream, 339 NSDictionary *dict, 340 GPBFieldDescriptor *field) { 341 NSCAssert(field.mapKeyDataType == GPBDataTypeString, @"Unexpected key type"); 342 GPBDataType mapValueType = GPBGetFieldDataType(field); 343 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 344 [dict enumerateKeysAndObjectsUsingBlock:^(NSString *key, id obj, BOOL *stop) { 345 #pragma unused(stop) 346 // Write the tag. 347 [outputStream writeInt32NoTag:tag]; 348 // Write the size of the message. 349 size_t msgSize = GPBComputeStringSize(kMapKeyFieldNumber, key); 350 msgSize += ComputeDictObjectFieldSize(obj, kMapValueFieldNumber, mapValueType); 351 352 // Write the size and fields. 353 [outputStream writeInt32NoTag:(int32_t)msgSize]; 354 [outputStream writeString:kMapKeyFieldNumber value:key]; 355 WriteDictObjectField(outputStream, obj, kMapValueFieldNumber, mapValueType); 356 }]; 357 } 358 359 BOOL GPBDictionaryIsInitializedInternalHelper(NSDictionary *dict, GPBFieldDescriptor *field) { 360 NSCAssert(field.mapKeyDataType == GPBDataTypeString, @"Unexpected key type"); 361 NSCAssert(GPBGetFieldDataType(field) == GPBDataTypeMessage, @"Unexpected value type"); 362 #pragma unused(field) // For when asserts are off in release. 363 for (GPBMessage *msg in [dict objectEnumerator]) { 364 if (!msg.initialized) { 365 return NO; 366 } 367 } 368 return YES; 369 } 370 371 // Note: if the type is an object, it the retain pass back to the caller. 372 static void ReadValue(GPBCodedInputStream *stream, 373 GPBGenericValue *valueToFill, 374 GPBDataType type, 375 GPBExtensionRegistry *registry, 376 GPBFieldDescriptor *field) { 377 switch (type) { 378 case GPBDataTypeBool: 379 valueToFill->valueBool = GPBCodedInputStreamReadBool(&stream->state_); 380 break; 381 case GPBDataTypeFixed32: 382 valueToFill->valueUInt32 = GPBCodedInputStreamReadFixed32(&stream->state_); 383 break; 384 case GPBDataTypeSFixed32: 385 valueToFill->valueInt32 = GPBCodedInputStreamReadSFixed32(&stream->state_); 386 break; 387 case GPBDataTypeFloat: 388 valueToFill->valueFloat = GPBCodedInputStreamReadFloat(&stream->state_); 389 break; 390 case GPBDataTypeFixed64: 391 valueToFill->valueUInt64 = GPBCodedInputStreamReadFixed64(&stream->state_); 392 break; 393 case GPBDataTypeSFixed64: 394 valueToFill->valueInt64 = GPBCodedInputStreamReadSFixed64(&stream->state_); 395 break; 396 case GPBDataTypeDouble: 397 valueToFill->valueDouble = GPBCodedInputStreamReadDouble(&stream->state_); 398 break; 399 case GPBDataTypeInt32: 400 valueToFill->valueInt32 = GPBCodedInputStreamReadInt32(&stream->state_); 401 break; 402 case GPBDataTypeInt64: 403 valueToFill->valueInt64 = GPBCodedInputStreamReadInt32(&stream->state_); 404 break; 405 case GPBDataTypeSInt32: 406 valueToFill->valueInt32 = GPBCodedInputStreamReadSInt32(&stream->state_); 407 break; 408 case GPBDataTypeSInt64: 409 valueToFill->valueInt64 = GPBCodedInputStreamReadSInt64(&stream->state_); 410 break; 411 case GPBDataTypeUInt32: 412 valueToFill->valueUInt32 = GPBCodedInputStreamReadUInt32(&stream->state_); 413 break; 414 case GPBDataTypeUInt64: 415 valueToFill->valueUInt64 = GPBCodedInputStreamReadUInt64(&stream->state_); 416 break; 417 case GPBDataTypeBytes: 418 [valueToFill->valueData release]; 419 valueToFill->valueData = GPBCodedInputStreamReadRetainedBytes(&stream->state_); 420 break; 421 case GPBDataTypeString: 422 [valueToFill->valueString release]; 423 valueToFill->valueString = GPBCodedInputStreamReadRetainedString(&stream->state_); 424 break; 425 case GPBDataTypeMessage: { 426 GPBMessage *message = [[field.msgClass alloc] init]; 427 [stream readMessage:message extensionRegistry:registry]; 428 [valueToFill->valueMessage release]; 429 valueToFill->valueMessage = message; 430 break; 431 } 432 case GPBDataTypeGroup: 433 NSCAssert(NO, @"Can't happen"); 434 break; 435 case GPBDataTypeEnum: 436 valueToFill->valueEnum = GPBCodedInputStreamReadEnum(&stream->state_); 437 break; 438 } 439 } 440 441 void GPBDictionaryReadEntry(id mapDictionary, 442 GPBCodedInputStream *stream, 443 GPBExtensionRegistry *registry, 444 GPBFieldDescriptor *field, 445 GPBMessage *parentMessage) { 446 GPBDataType keyDataType = field.mapKeyDataType; 447 GPBDataType valueDataType = GPBGetFieldDataType(field); 448 449 GPBGenericValue key; 450 GPBGenericValue value; 451 // Zero them (but pick up any enum default for proto2). 452 key.valueString = value.valueString = nil; 453 if (valueDataType == GPBDataTypeEnum) { 454 value = field.defaultValue; 455 } 456 457 GPBCodedInputStreamState *state = &stream->state_; 458 uint32_t keyTag = 459 GPBWireFormatMakeTag(kMapKeyFieldNumber, GPBWireFormatForType(keyDataType, NO)); 460 uint32_t valueTag = 461 GPBWireFormatMakeTag(kMapValueFieldNumber, GPBWireFormatForType(valueDataType, NO)); 462 463 BOOL hitError = NO; 464 while (YES) { 465 uint32_t tag = GPBCodedInputStreamReadTag(state); 466 if (tag == keyTag) { 467 ReadValue(stream, &key, keyDataType, registry, field); 468 } else if (tag == valueTag) { 469 ReadValue(stream, &value, valueDataType, registry, field); 470 } else if (tag == 0) { 471 // zero signals EOF / limit reached 472 break; 473 } else { // Unknown 474 if (![stream skipField:tag]){ 475 hitError = YES; 476 break; 477 } 478 } 479 } 480 481 if (!hitError) { 482 // Handle the special defaults and/or missing key/value. 483 if ((keyDataType == GPBDataTypeString) && (key.valueString == nil)) { 484 key.valueString = [@"" retain]; 485 } 486 if (GPBDataTypeIsObject(valueDataType) && value.valueString == nil) { 487 switch (valueDataType) { 488 case GPBDataTypeString: 489 value.valueString = [@"" retain]; 490 break; 491 case GPBDataTypeBytes: 492 value.valueData = [GPBEmptyNSData() retain]; 493 break; 494 #if defined(__clang_analyzer__) 495 case GPBDataTypeGroup: 496 // Maps can't really have Groups as the value type, but this case is needed 497 // so the analyzer won't report the posibility of send nil in for the value 498 // in the NSMutableDictionary case below. 499 #endif 500 case GPBDataTypeMessage: { 501 value.valueMessage = [[field.msgClass alloc] init]; 502 break; 503 } 504 default: 505 // Nothing 506 break; 507 } 508 } 509 510 if ((keyDataType == GPBDataTypeString) && GPBDataTypeIsObject(valueDataType)) { 511 #if GPB_STATIC_ANALYZER_ONLY(6020053, 7000181) 512 // Limited to Xcode 6.4 - 7.2, are known to fail here. The upper end can 513 // be raised as needed for new Xcodes. 514 // 515 // This is only needed on a "shallow" analyze; on a "deep" analyze, the 516 // existing code path gets this correct. In shallow, the analyzer decides 517 // GPBDataTypeIsObject(valueDataType) is both false and true on a single 518 // path through this function, allowing nil to be used for the 519 // setObject:forKey:. 520 if (value.valueString == nil) { 521 value.valueString = [@"" retain]; 522 } 523 #endif 524 // mapDictionary is an NSMutableDictionary 525 [(NSMutableDictionary *)mapDictionary setObject:value.valueString 526 forKey:key.valueString]; 527 } else { 528 if (valueDataType == GPBDataTypeEnum) { 529 if (GPBHasPreservingUnknownEnumSemantics([parentMessage descriptor].file.syntax) || 530 [field isValidEnumValue:value.valueEnum]) { 531 [mapDictionary setGPBGenericValue:&value forGPBGenericValueKey:&key]; 532 } else { 533 NSData *data = [mapDictionary serializedDataForUnknownValue:value.valueEnum 534 forKey:&key 535 keyDataType:keyDataType]; 536 [parentMessage addUnknownMapEntry:GPBFieldNumber(field) value:data]; 537 } 538 } else { 539 [mapDictionary setGPBGenericValue:&value forGPBGenericValueKey:&key]; 540 } 541 } 542 } 543 544 if (GPBDataTypeIsObject(keyDataType)) { 545 [key.valueString release]; 546 } 547 if (GPBDataTypeIsObject(valueDataType)) { 548 [value.valueString release]; 549 } 550 } 551 552 // 553 // Macros for the common basic cases. 554 // 555 556 //%PDDM-DEFINE DICTIONARY_IMPL_FOR_POD_KEY(KEY_NAME, KEY_TYPE) 557 //%DICTIONARY_POD_IMPL_FOR_KEY(KEY_NAME, KEY_TYPE, , POD) 558 //%DICTIONARY_POD_KEY_TO_OBJECT_IMPL(KEY_NAME, KEY_TYPE, Object, id) 559 560 //%PDDM-DEFINE DICTIONARY_POD_IMPL_FOR_KEY(KEY_NAME, KEY_TYPE, KisP, KHELPER) 561 //%DICTIONARY_KEY_TO_POD_IMPL(KEY_NAME, KEY_TYPE, KisP, UInt32, uint32_t, KHELPER) 562 //%DICTIONARY_KEY_TO_POD_IMPL(KEY_NAME, KEY_TYPE, KisP, Int32, int32_t, KHELPER) 563 //%DICTIONARY_KEY_TO_POD_IMPL(KEY_NAME, KEY_TYPE, KisP, UInt64, uint64_t, KHELPER) 564 //%DICTIONARY_KEY_TO_POD_IMPL(KEY_NAME, KEY_TYPE, KisP, Int64, int64_t, KHELPER) 565 //%DICTIONARY_KEY_TO_POD_IMPL(KEY_NAME, KEY_TYPE, KisP, Bool, BOOL, KHELPER) 566 //%DICTIONARY_KEY_TO_POD_IMPL(KEY_NAME, KEY_TYPE, KisP, Float, float, KHELPER) 567 //%DICTIONARY_KEY_TO_POD_IMPL(KEY_NAME, KEY_TYPE, KisP, Double, double, KHELPER) 568 //%DICTIONARY_KEY_TO_ENUM_IMPL(KEY_NAME, KEY_TYPE, KisP, Enum, int32_t, KHELPER) 569 570 //%PDDM-DEFINE DICTIONARY_KEY_TO_POD_IMPL(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER) 571 //%DICTIONARY_COMMON_IMPL(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, POD, value) 572 573 //%PDDM-DEFINE DICTIONARY_POD_KEY_TO_OBJECT_IMPL(KEY_NAME, KEY_TYPE, VALUE_NAME, VALUE_TYPE) 574 //%DICTIONARY_COMMON_IMPL(KEY_NAME, KEY_TYPE, , VALUE_NAME, VALUE_TYPE, POD, OBJECT, object) 575 576 //%PDDM-DEFINE DICTIONARY_COMMON_IMPL(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, VNAME) 577 //%#pragma mark - KEY_NAME -> VALUE_NAME 578 //% 579 //%@implementation GPB##KEY_NAME##VALUE_NAME##Dictionary { 580 //% @package 581 //% NSMutableDictionary *_dictionary; 582 //%} 583 //% 584 //%+ (instancetype)dictionary { 585 //% return [[[self alloc] initWith##VNAME$u##s:NULL forKeys:NULL count:0] autorelease]; 586 //%} 587 //% 588 //%+ (instancetype)dictionaryWith##VNAME$u##:(VALUE_TYPE)##VNAME 589 //% ##VNAME$S## forKey:(KEY_TYPE##KisP$S##KisP)key { 590 //% // Cast is needed so the compiler knows what class we are invoking initWith##VNAME$u##s:forKeys:count: 591 //% // on to get the type correct. 592 //% return [[(GPB##KEY_NAME##VALUE_NAME##Dictionary*)[self alloc] initWith##VNAME$u##s:&##VNAME 593 //% KEY_NAME$S VALUE_NAME$S ##VNAME$S## forKeys:&key 594 //% KEY_NAME$S VALUE_NAME$S ##VNAME$S## count:1] autorelease]; 595 //%} 596 //% 597 //%+ (instancetype)dictionaryWith##VNAME$u##s:(const VALUE_TYPE [])##VNAME##s 598 //% ##VNAME$S## forKeys:(const KEY_TYPE##KisP$S##KisP [])keys 599 //% ##VNAME$S## count:(NSUInteger)count { 600 //% // Cast is needed so the compiler knows what class we are invoking initWith##VNAME$u##s:forKeys:count: 601 //% // on to get the type correct. 602 //% return [[(GPB##KEY_NAME##VALUE_NAME##Dictionary*)[self alloc] initWith##VNAME$u##s:##VNAME##s 603 //% KEY_NAME$S VALUE_NAME$S forKeys:keys 604 //% KEY_NAME$S VALUE_NAME$S count:count] autorelease]; 605 //%} 606 //% 607 //%+ (instancetype)dictionaryWithDictionary:(GPB##KEY_NAME##VALUE_NAME##Dictionary *)dictionary { 608 //% // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 609 //% // on to get the type correct. 610 //% return [[(GPB##KEY_NAME##VALUE_NAME##Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 611 //%} 612 //% 613 //%+ (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 614 //% return [[[self alloc] initWithCapacity:numItems] autorelease]; 615 //%} 616 //% 617 //%- (instancetype)init { 618 //% return [self initWith##VNAME$u##s:NULL forKeys:NULL count:0]; 619 //%} 620 //% 621 //%- (instancetype)initWith##VNAME$u##s:(const VALUE_TYPE [])##VNAME##s 622 //% ##VNAME$S## forKeys:(const KEY_TYPE##KisP$S##KisP [])keys 623 //% ##VNAME$S## count:(NSUInteger)count { 624 //% self = [super init]; 625 //% if (self) { 626 //% _dictionary = [[NSMutableDictionary alloc] init]; 627 //% if (count && VNAME##s && keys) { 628 //% for (NSUInteger i = 0; i < count; ++i) { 629 //%DICTIONARY_VALIDATE_VALUE_##VHELPER(VNAME##s[i], ______)##DICTIONARY_VALIDATE_KEY_##KHELPER(keys[i], ______) [_dictionary setObject:WRAPPED##VHELPER(VNAME##s[i]) forKey:WRAPPED##KHELPER(keys[i])]; 630 //% } 631 //% } 632 //% } 633 //% return self; 634 //%} 635 //% 636 //%- (instancetype)initWithDictionary:(GPB##KEY_NAME##VALUE_NAME##Dictionary *)dictionary { 637 //% self = [self initWith##VNAME$u##s:NULL forKeys:NULL count:0]; 638 //% if (self) { 639 //% if (dictionary) { 640 //% [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 641 //% } 642 //% } 643 //% return self; 644 //%} 645 //% 646 //%- (instancetype)initWithCapacity:(NSUInteger)numItems { 647 //% #pragma unused(numItems) 648 //% return [self initWith##VNAME$u##s:NULL forKeys:NULL count:0]; 649 //%} 650 //% 651 //%DICTIONARY_IMMUTABLE_CORE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, VNAME, ) 652 //% 653 //%VALUE_FOR_KEY_##VHELPER(KEY_TYPE##KisP$S##KisP, VALUE_NAME, VALUE_TYPE, KHELPER) 654 //% 655 //%DICTIONARY_MUTABLE_CORE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, VNAME, ) 656 //% 657 //%@end 658 //% 659 660 //%PDDM-DEFINE DICTIONARY_KEY_TO_ENUM_IMPL(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER) 661 //%DICTIONARY_KEY_TO_ENUM_IMPL2(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, POD) 662 //%PDDM-DEFINE DICTIONARY_KEY_TO_ENUM_IMPL2(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER) 663 //%#pragma mark - KEY_NAME -> VALUE_NAME 664 //% 665 //%@implementation GPB##KEY_NAME##VALUE_NAME##Dictionary { 666 //% @package 667 //% NSMutableDictionary *_dictionary; 668 //% GPBEnumValidationFunc _validationFunc; 669 //%} 670 //% 671 //%@synthesize validationFunc = _validationFunc; 672 //% 673 //%+ (instancetype)dictionary { 674 //% return [[[self alloc] initWithValidationFunction:NULL 675 //% rawValues:NULL 676 //% forKeys:NULL 677 //% count:0] autorelease]; 678 //%} 679 //% 680 //%+ (instancetype)dictionaryWithValidationFunction:(GPBEnumValidationFunc)func { 681 //% return [[[self alloc] initWithValidationFunction:func 682 //% rawValues:NULL 683 //% forKeys:NULL 684 //% count:0] autorelease]; 685 //%} 686 //% 687 //%+ (instancetype)dictionaryWithValidationFunction:(GPBEnumValidationFunc)func 688 //% rawValue:(VALUE_TYPE)rawValue 689 //% forKey:(KEY_TYPE##KisP$S##KisP)key { 690 //% // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 691 //% // on to get the type correct. 692 //% return [[(GPB##KEY_NAME##VALUE_NAME##Dictionary*)[self alloc] initWithValidationFunction:func 693 //% KEY_NAME$S VALUE_NAME$S rawValues:&rawValue 694 //% KEY_NAME$S VALUE_NAME$S forKeys:&key 695 //% KEY_NAME$S VALUE_NAME$S count:1] autorelease]; 696 //%} 697 //% 698 //%+ (instancetype)dictionaryWithValidationFunction:(GPBEnumValidationFunc)func 699 //% rawValues:(const VALUE_TYPE [])rawValues 700 //% forKeys:(const KEY_TYPE##KisP$S##KisP [])keys 701 //% count:(NSUInteger)count { 702 //% // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 703 //% // on to get the type correct. 704 //% return [[(GPB##KEY_NAME##VALUE_NAME##Dictionary*)[self alloc] initWithValidationFunction:func 705 //% KEY_NAME$S VALUE_NAME$S rawValues:rawValues 706 //% KEY_NAME$S VALUE_NAME$S forKeys:keys 707 //% KEY_NAME$S VALUE_NAME$S count:count] autorelease]; 708 //%} 709 //% 710 //%+ (instancetype)dictionaryWithDictionary:(GPB##KEY_NAME##VALUE_NAME##Dictionary *)dictionary { 711 //% // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 712 //% // on to get the type correct. 713 //% return [[(GPB##KEY_NAME##VALUE_NAME##Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 714 //%} 715 //% 716 //%+ (instancetype)dictionaryWithValidationFunction:(GPBEnumValidationFunc)func 717 //% capacity:(NSUInteger)numItems { 718 //% return [[[self alloc] initWithValidationFunction:func capacity:numItems] autorelease]; 719 //%} 720 //% 721 //%- (instancetype)init { 722 //% return [self initWithValidationFunction:NULL rawValues:NULL forKeys:NULL count:0]; 723 //%} 724 //% 725 //%- (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func { 726 //% return [self initWithValidationFunction:func rawValues:NULL forKeys:NULL count:0]; 727 //%} 728 //% 729 //%- (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func 730 //% rawValues:(const VALUE_TYPE [])rawValues 731 //% forKeys:(const KEY_TYPE##KisP$S##KisP [])keys 732 //% count:(NSUInteger)count { 733 //% self = [super init]; 734 //% if (self) { 735 //% _dictionary = [[NSMutableDictionary alloc] init]; 736 //% _validationFunc = (func != NULL ? func : DictDefault_IsValidValue); 737 //% if (count && rawValues && keys) { 738 //% for (NSUInteger i = 0; i < count; ++i) { 739 //%DICTIONARY_VALIDATE_KEY_##KHELPER(keys[i], ______) [_dictionary setObject:WRAPPED##VHELPER(rawValues[i]) forKey:WRAPPED##KHELPER(keys[i])]; 740 //% } 741 //% } 742 //% } 743 //% return self; 744 //%} 745 //% 746 //%- (instancetype)initWithDictionary:(GPB##KEY_NAME##VALUE_NAME##Dictionary *)dictionary { 747 //% self = [self initWithValidationFunction:dictionary.validationFunc 748 //% rawValues:NULL 749 //% forKeys:NULL 750 //% count:0]; 751 //% if (self) { 752 //% if (dictionary) { 753 //% [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 754 //% } 755 //% } 756 //% return self; 757 //%} 758 //% 759 //%- (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func 760 //% capacity:(NSUInteger)numItems { 761 //% #pragma unused(numItems) 762 //% return [self initWithValidationFunction:func rawValues:NULL forKeys:NULL count:0]; 763 //%} 764 //% 765 //%DICTIONARY_IMMUTABLE_CORE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, value, Raw) 766 //% 767 //%- (BOOL)valueForKey:(KEY_TYPE##KisP$S##KisP)key value:(VALUE_TYPE *)value { 768 //% NSNumber *wrapped = [_dictionary objectForKey:WRAPPED##KHELPER(key)]; 769 //% if (wrapped && value) { 770 //% VALUE_TYPE result = UNWRAP##VALUE_NAME(wrapped); 771 //% if (!_validationFunc(result)) { 772 //% result = kGPBUnrecognizedEnumeratorValue; 773 //% } 774 //% *value = result; 775 //% } 776 //% return (wrapped != NULL); 777 //%} 778 //% 779 //%- (BOOL)valueForKey:(KEY_TYPE##KisP$S##KisP)key rawValue:(VALUE_TYPE *)rawValue { 780 //% NSNumber *wrapped = [_dictionary objectForKey:WRAPPED##KHELPER(key)]; 781 //% if (wrapped && rawValue) { 782 //% *rawValue = UNWRAP##VALUE_NAME(wrapped); 783 //% } 784 //% return (wrapped != NULL); 785 //%} 786 //% 787 //%- (void)enumerateKeysAndValuesUsingBlock: 788 //% (void (^)(KEY_TYPE KisP##key, VALUE_TYPE value, BOOL *stop))block { 789 //% GPBEnumValidationFunc func = _validationFunc; 790 //% [_dictionary enumerateKeysAndObjectsUsingBlock:^(ENUM_TYPE##KHELPER(KEY_TYPE)##aKey, 791 //% ENUM_TYPE##VHELPER(VALUE_TYPE)##aValue, 792 //% BOOL *stop) { 793 //% VALUE_TYPE unwrapped = UNWRAP##VALUE_NAME(aValue); 794 //% if (!func(unwrapped)) { 795 //% unwrapped = kGPBUnrecognizedEnumeratorValue; 796 //% } 797 //% block(UNWRAP##KEY_NAME(aKey), unwrapped, stop); 798 //% }]; 799 //%} 800 //% 801 //%DICTIONARY_MUTABLE_CORE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, value, Raw) 802 //% 803 //%- (void)setValue:(VALUE_TYPE)value forKey:(KEY_TYPE##KisP$S##KisP)key { 804 //%DICTIONARY_VALIDATE_KEY_##KHELPER(key, ) if (!_validationFunc(value)) { 805 //% [NSException raise:NSInvalidArgumentException 806 //% format:@"GPB##KEY_NAME##VALUE_NAME##Dictionary: Attempt to set an unknown enum value (%d)", 807 //% value]; 808 //% } 809 //% 810 //% [_dictionary setObject:WRAPPED##VHELPER(value) forKey:WRAPPED##KHELPER(key)]; 811 //% if (_autocreator) { 812 //% GPBAutocreatedDictionaryModified(_autocreator, self); 813 //% } 814 //%} 815 //% 816 //%@end 817 //% 818 819 //%PDDM-DEFINE DICTIONARY_IMMUTABLE_CORE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, VNAME, ACCESSOR_NAME) 820 //%- (void)dealloc { 821 //% NSAssert(!_autocreator, 822 //% @"%@: Autocreator must be cleared before release, autocreator: %@", 823 //% [self class], _autocreator); 824 //% [_dictionary release]; 825 //% [super dealloc]; 826 //%} 827 //% 828 //%- (instancetype)copyWithZone:(NSZone *)zone { 829 //% return [[GPB##KEY_NAME##VALUE_NAME##Dictionary allocWithZone:zone] initWithDictionary:self]; 830 //%} 831 //% 832 //%- (BOOL)isEqual:(GPB##KEY_NAME##VALUE_NAME##Dictionary *)other { 833 //% if (self == other) { 834 //% return YES; 835 //% } 836 //% if (![other isKindOfClass:[GPB##KEY_NAME##VALUE_NAME##Dictionary class]]) { 837 //% return NO; 838 //% } 839 //% return [_dictionary isEqual:other->_dictionary]; 840 //%} 841 //% 842 //%- (NSUInteger)hash { 843 //% return _dictionary.count; 844 //%} 845 //% 846 //%- (NSString *)description { 847 //% return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 848 //%} 849 //% 850 //%- (NSUInteger)count { 851 //% return _dictionary.count; 852 //%} 853 //% 854 //%- (void)enumerateKeysAnd##ACCESSOR_NAME##VNAME$u##sUsingBlock: 855 //% (void (^)(KEY_TYPE KisP##key, VALUE_TYPE VNAME, BOOL *stop))block { 856 //% [_dictionary enumerateKeysAndObjectsUsingBlock:^(ENUM_TYPE##KHELPER(KEY_TYPE)##aKey, 857 //% ENUM_TYPE##VHELPER(VALUE_TYPE)##a##VNAME$u, 858 //% BOOL *stop) { 859 //% block(UNWRAP##KEY_NAME(aKey), UNWRAP##VALUE_NAME(a##VNAME$u), stop); 860 //% }]; 861 //%} 862 //% 863 //%EXTRA_METHODS_##VHELPER(KEY_NAME, VALUE_NAME)- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 864 //% NSUInteger count = _dictionary.count; 865 //% if (count == 0) { 866 //% return 0; 867 //% } 868 //% 869 //% GPBDataType valueDataType = GPBGetFieldDataType(field); 870 //% GPBDataType keyDataType = field.mapKeyDataType; 871 //% __block size_t result = 0; 872 //% [_dictionary enumerateKeysAndObjectsUsingBlock:^(ENUM_TYPE##KHELPER(KEY_TYPE)##aKey, 873 //% ENUM_TYPE##VHELPER(VALUE_TYPE)##a##VNAME$u##, 874 //% BOOL *stop) { 875 //% #pragma unused(stop) 876 //% size_t msgSize = ComputeDict##KEY_NAME##FieldSize(UNWRAP##KEY_NAME(aKey), kMapKeyFieldNumber, keyDataType); 877 //% msgSize += ComputeDict##VALUE_NAME##FieldSize(UNWRAP##VALUE_NAME(a##VNAME$u), kMapValueFieldNumber, valueDataType); 878 //% result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 879 //% }]; 880 //% size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 881 //% result += tagSize * count; 882 //% return result; 883 //%} 884 //% 885 //%- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 886 //% asField:(GPBFieldDescriptor *)field { 887 //% GPBDataType valueDataType = GPBGetFieldDataType(field); 888 //% GPBDataType keyDataType = field.mapKeyDataType; 889 //% uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 890 //% [_dictionary enumerateKeysAndObjectsUsingBlock:^(ENUM_TYPE##KHELPER(KEY_TYPE)##aKey, 891 //% ENUM_TYPE##VHELPER(VALUE_TYPE)##a##VNAME$u, 892 //% BOOL *stop) { 893 //% #pragma unused(stop) 894 //% // Write the tag. 895 //% [outputStream writeInt32NoTag:tag]; 896 //% // Write the size of the message. 897 //% size_t msgSize = ComputeDict##KEY_NAME##FieldSize(UNWRAP##KEY_NAME(aKey), kMapKeyFieldNumber, keyDataType); 898 //% msgSize += ComputeDict##VALUE_NAME##FieldSize(UNWRAP##VALUE_NAME(a##VNAME$u), kMapValueFieldNumber, valueDataType); 899 //% [outputStream writeInt32NoTag:(int32_t)msgSize]; 900 //% // Write the fields. 901 //% WriteDict##KEY_NAME##Field(outputStream, UNWRAP##KEY_NAME(aKey), kMapKeyFieldNumber, keyDataType); 902 //% WriteDict##VALUE_NAME##Field(outputStream, UNWRAP##VALUE_NAME(a##VNAME$u), kMapValueFieldNumber, valueDataType); 903 //% }]; 904 //%} 905 //% 906 //%SERIAL_DATA_FOR_ENTRY_##VHELPER(KEY_NAME, VALUE_NAME)- (void)setGPBGenericValue:(GPBGenericValue *)value 907 //% forGPBGenericValueKey:(GPBGenericValue *)key { 908 //% [_dictionary setObject:WRAPPED##VHELPER(value->##GPBVALUE_##VHELPER(VALUE_NAME)##) forKey:WRAPPED##KHELPER(key->value##KEY_NAME)]; 909 //%} 910 //% 911 //%- (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 912 //% [self enumerateKeysAnd##ACCESSOR_NAME##VNAME$u##sUsingBlock:^(KEY_TYPE KisP##key, VALUE_TYPE VNAME, BOOL *stop) { 913 //% #pragma unused(stop) 914 //% block(TEXT_FORMAT_OBJ##KEY_NAME(key), TEXT_FORMAT_OBJ##VALUE_NAME(VNAME)); 915 //% }]; 916 //%} 917 //%PDDM-DEFINE DICTIONARY_MUTABLE_CORE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, VNAME, ACCESSOR_NAME) 918 //%- (void)add##ACCESSOR_NAME##EntriesFromDictionary:(GPB##KEY_NAME##VALUE_NAME##Dictionary *)otherDictionary { 919 //% if (otherDictionary) { 920 //% [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 921 //% if (_autocreator) { 922 //% GPBAutocreatedDictionaryModified(_autocreator, self); 923 //% } 924 //% } 925 //%} 926 //% 927 //%- (void)set##ACCESSOR_NAME##VNAME$u##:(VALUE_TYPE)VNAME forKey:(KEY_TYPE##KisP$S##KisP)key { 928 //%DICTIONARY_VALIDATE_VALUE_##VHELPER(VNAME, )##DICTIONARY_VALIDATE_KEY_##KHELPER(key, ) [_dictionary setObject:WRAPPED##VHELPER(VNAME) forKey:WRAPPED##KHELPER(key)]; 929 //% if (_autocreator) { 930 //% GPBAutocreatedDictionaryModified(_autocreator, self); 931 //% } 932 //%} 933 //% 934 //%- (void)remove##VNAME$u##ForKey:(KEY_TYPE##KisP$S##KisP)aKey { 935 //% [_dictionary removeObjectForKey:WRAPPED##KHELPER(aKey)]; 936 //%} 937 //% 938 //%- (void)removeAll { 939 //% [_dictionary removeAllObjects]; 940 //%} 941 942 // 943 // Custom Generation for Bool keys 944 // 945 946 //%PDDM-DEFINE DICTIONARY_BOOL_KEY_TO_POD_IMPL(VALUE_NAME, VALUE_TYPE) 947 //%DICTIONARY_BOOL_KEY_TO_VALUE_IMPL(VALUE_NAME, VALUE_TYPE, POD, value) 948 //%PDDM-DEFINE DICTIONARY_BOOL_KEY_TO_OBJECT_IMPL(VALUE_NAME, VALUE_TYPE) 949 //%DICTIONARY_BOOL_KEY_TO_VALUE_IMPL(VALUE_NAME, VALUE_TYPE, OBJECT, object) 950 951 //%PDDM-DEFINE DICTIONARY_BOOL_KEY_TO_VALUE_IMPL(VALUE_NAME, VALUE_TYPE, HELPER, VNAME) 952 //%#pragma mark - Bool -> VALUE_NAME 953 //% 954 //%@implementation GPBBool##VALUE_NAME##Dictionary { 955 //% @package 956 //% VALUE_TYPE _values[2]; 957 //%BOOL_DICT_HAS_STORAGE_##HELPER()} 958 //% 959 //%+ (instancetype)dictionary { 960 //% return [[[self alloc] initWith##VNAME$u##s:NULL forKeys:NULL count:0] autorelease]; 961 //%} 962 //% 963 //%+ (instancetype)dictionaryWith##VNAME$u##:(VALUE_TYPE)VNAME 964 //% ##VNAME$S## forKey:(BOOL)key { 965 //% // Cast is needed so the compiler knows what class we are invoking initWith##VNAME$u##s:forKeys:count: 966 //% // on to get the type correct. 967 //% return [[(GPBBool##VALUE_NAME##Dictionary*)[self alloc] initWith##VNAME$u##s:&##VNAME 968 //% VALUE_NAME$S ##VNAME$S## forKeys:&key 969 //% VALUE_NAME$S ##VNAME$S## count:1] autorelease]; 970 //%} 971 //% 972 //%+ (instancetype)dictionaryWith##VNAME$u##s:(const VALUE_TYPE [])##VNAME##s 973 //% ##VNAME$S## forKeys:(const BOOL [])keys 974 //% ##VNAME$S## count:(NSUInteger)count { 975 //% // Cast is needed so the compiler knows what class we are invoking initWith##VNAME$u##s:forKeys:count: 976 //% // on to get the type correct. 977 //% return [[(GPBBool##VALUE_NAME##Dictionary*)[self alloc] initWith##VNAME$u##s:##VNAME##s 978 //% VALUE_NAME$S ##VNAME$S## forKeys:keys 979 //% VALUE_NAME$S ##VNAME$S## count:count] autorelease]; 980 //%} 981 //% 982 //%+ (instancetype)dictionaryWithDictionary:(GPBBool##VALUE_NAME##Dictionary *)dictionary { 983 //% // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 984 //% // on to get the type correct. 985 //% return [[(GPBBool##VALUE_NAME##Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 986 //%} 987 //% 988 //%+ (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 989 //% return [[[self alloc] initWithCapacity:numItems] autorelease]; 990 //%} 991 //% 992 //%- (instancetype)init { 993 //% return [self initWith##VNAME$u##s:NULL forKeys:NULL count:0]; 994 //%} 995 //% 996 //%BOOL_DICT_INITS_##HELPER(VALUE_NAME, VALUE_TYPE) 997 //% 998 //%- (instancetype)initWithCapacity:(NSUInteger)numItems { 999 //% #pragma unused(numItems) 1000 //% return [self initWith##VNAME$u##s:NULL forKeys:NULL count:0]; 1001 //%} 1002 //% 1003 //%BOOL_DICT_DEALLOC##HELPER() 1004 //% 1005 //%- (instancetype)copyWithZone:(NSZone *)zone { 1006 //% return [[GPBBool##VALUE_NAME##Dictionary allocWithZone:zone] initWithDictionary:self]; 1007 //%} 1008 //% 1009 //%- (BOOL)isEqual:(GPBBool##VALUE_NAME##Dictionary *)other { 1010 //% if (self == other) { 1011 //% return YES; 1012 //% } 1013 //% if (![other isKindOfClass:[GPBBool##VALUE_NAME##Dictionary class]]) { 1014 //% return NO; 1015 //% } 1016 //% if ((BOOL_DICT_W_HAS##HELPER(0, ) != BOOL_DICT_W_HAS##HELPER(0, other->)) || 1017 //% (BOOL_DICT_W_HAS##HELPER(1, ) != BOOL_DICT_W_HAS##HELPER(1, other->))) { 1018 //% return NO; 1019 //% } 1020 //% if ((BOOL_DICT_W_HAS##HELPER(0, ) && (NEQ_##HELPER(_values[0], other->_values[0]))) || 1021 //% (BOOL_DICT_W_HAS##HELPER(1, ) && (NEQ_##HELPER(_values[1], other->_values[1])))) { 1022 //% return NO; 1023 //% } 1024 //% return YES; 1025 //%} 1026 //% 1027 //%- (NSUInteger)hash { 1028 //% return (BOOL_DICT_W_HAS##HELPER(0, ) ? 1 : 0) + (BOOL_DICT_W_HAS##HELPER(1, ) ? 1 : 0); 1029 //%} 1030 //% 1031 //%- (NSString *)description { 1032 //% NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> {", [self class], self]; 1033 //% if (BOOL_DICT_W_HAS##HELPER(0, )) { 1034 //% [result appendFormat:@"NO: STR_FORMAT_##HELPER(VALUE_NAME)", _values[0]]; 1035 //% } 1036 //% if (BOOL_DICT_W_HAS##HELPER(1, )) { 1037 //% [result appendFormat:@"YES: STR_FORMAT_##HELPER(VALUE_NAME)", _values[1]]; 1038 //% } 1039 //% [result appendString:@" }"]; 1040 //% return result; 1041 //%} 1042 //% 1043 //%- (NSUInteger)count { 1044 //% return (BOOL_DICT_W_HAS##HELPER(0, ) ? 1 : 0) + (BOOL_DICT_W_HAS##HELPER(1, ) ? 1 : 0); 1045 //%} 1046 //% 1047 //%BOOL_VALUE_FOR_KEY_##HELPER(VALUE_TYPE) 1048 //% 1049 //%BOOL_SET_GPBVALUE_FOR_KEY_##HELPER(VALUE_NAME, VALUE_TYPE, VisP) 1050 //% 1051 //%- (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 1052 //% if (BOOL_DICT_HAS##HELPER(0, )) { 1053 //% block(@"false", TEXT_FORMAT_OBJ##VALUE_NAME(_values[0])); 1054 //% } 1055 //% if (BOOL_DICT_W_HAS##HELPER(1, )) { 1056 //% block(@"true", TEXT_FORMAT_OBJ##VALUE_NAME(_values[1])); 1057 //% } 1058 //%} 1059 //% 1060 //%- (void)enumerateKeysAnd##VNAME$u##sUsingBlock: 1061 //% (void (^)(BOOL key, VALUE_TYPE VNAME, BOOL *stop))block { 1062 //% BOOL stop = NO; 1063 //% if (BOOL_DICT_HAS##HELPER(0, )) { 1064 //% block(NO, _values[0], &stop); 1065 //% } 1066 //% if (!stop && BOOL_DICT_W_HAS##HELPER(1, )) { 1067 //% block(YES, _values[1], &stop); 1068 //% } 1069 //%} 1070 //% 1071 //%BOOL_EXTRA_METHODS_##HELPER(Bool, VALUE_NAME)- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 1072 //% GPBDataType valueDataType = GPBGetFieldDataType(field); 1073 //% NSUInteger count = 0; 1074 //% size_t result = 0; 1075 //% for (int i = 0; i < 2; ++i) { 1076 //% if (BOOL_DICT_HAS##HELPER(i, )) { 1077 //% ++count; 1078 //% size_t msgSize = ComputeDictBoolFieldSize((i == 1), kMapKeyFieldNumber, GPBDataTypeBool); 1079 //% msgSize += ComputeDict##VALUE_NAME##FieldSize(_values[i], kMapValueFieldNumber, valueDataType); 1080 //% result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 1081 //% } 1082 //% } 1083 //% size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 1084 //% result += tagSize * count; 1085 //% return result; 1086 //%} 1087 //% 1088 //%- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 1089 //% asField:(GPBFieldDescriptor *)field { 1090 //% GPBDataType valueDataType = GPBGetFieldDataType(field); 1091 //% uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 1092 //% for (int i = 0; i < 2; ++i) { 1093 //% if (BOOL_DICT_HAS##HELPER(i, )) { 1094 //% // Write the tag. 1095 //% [outputStream writeInt32NoTag:tag]; 1096 //% // Write the size of the message. 1097 //% size_t msgSize = ComputeDictBoolFieldSize((i == 1), kMapKeyFieldNumber, GPBDataTypeBool); 1098 //% msgSize += ComputeDict##VALUE_NAME##FieldSize(_values[i], kMapValueFieldNumber, valueDataType); 1099 //% [outputStream writeInt32NoTag:(int32_t)msgSize]; 1100 //% // Write the fields. 1101 //% WriteDictBoolField(outputStream, (i == 1), kMapKeyFieldNumber, GPBDataTypeBool); 1102 //% WriteDict##VALUE_NAME##Field(outputStream, _values[i], kMapValueFieldNumber, valueDataType); 1103 //% } 1104 //% } 1105 //%} 1106 //% 1107 //%BOOL_DICT_MUTATIONS_##HELPER(VALUE_NAME, VALUE_TYPE) 1108 //% 1109 //%@end 1110 //% 1111 1112 1113 // 1114 // Helpers for PODs 1115 // 1116 1117 //%PDDM-DEFINE VALUE_FOR_KEY_POD(KEY_TYPE, VALUE_NAME, VALUE_TYPE, KHELPER) 1118 //%- (BOOL)valueForKey:(KEY_TYPE)key value:(VALUE_TYPE *)value { 1119 //% NSNumber *wrapped = [_dictionary objectForKey:WRAPPED##KHELPER(key)]; 1120 //% if (wrapped && value) { 1121 //% *value = UNWRAP##VALUE_NAME(wrapped); 1122 //% } 1123 //% return (wrapped != NULL); 1124 //%} 1125 //%PDDM-DEFINE WRAPPEDPOD(VALUE) 1126 //%@(VALUE) 1127 //%PDDM-DEFINE UNWRAPUInt32(VALUE) 1128 //%[VALUE unsignedIntValue] 1129 //%PDDM-DEFINE UNWRAPInt32(VALUE) 1130 //%[VALUE intValue] 1131 //%PDDM-DEFINE UNWRAPUInt64(VALUE) 1132 //%[VALUE unsignedLongLongValue] 1133 //%PDDM-DEFINE UNWRAPInt64(VALUE) 1134 //%[VALUE longLongValue] 1135 //%PDDM-DEFINE UNWRAPBool(VALUE) 1136 //%[VALUE boolValue] 1137 //%PDDM-DEFINE UNWRAPFloat(VALUE) 1138 //%[VALUE floatValue] 1139 //%PDDM-DEFINE UNWRAPDouble(VALUE) 1140 //%[VALUE doubleValue] 1141 //%PDDM-DEFINE UNWRAPEnum(VALUE) 1142 //%[VALUE intValue] 1143 //%PDDM-DEFINE TEXT_FORMAT_OBJUInt32(VALUE) 1144 //%[NSString stringWithFormat:@"%u", VALUE] 1145 //%PDDM-DEFINE TEXT_FORMAT_OBJInt32(VALUE) 1146 //%[NSString stringWithFormat:@"%d", VALUE] 1147 //%PDDM-DEFINE TEXT_FORMAT_OBJUInt64(VALUE) 1148 //%[NSString stringWithFormat:@"%llu", VALUE] 1149 //%PDDM-DEFINE TEXT_FORMAT_OBJInt64(VALUE) 1150 //%[NSString stringWithFormat:@"%lld", VALUE] 1151 //%PDDM-DEFINE TEXT_FORMAT_OBJBool(VALUE) 1152 //%(VALUE ? @"true" : @"false") 1153 //%PDDM-DEFINE TEXT_FORMAT_OBJFloat(VALUE) 1154 //%[NSString stringWithFormat:@"%.*g", FLT_DIG, VALUE] 1155 //%PDDM-DEFINE TEXT_FORMAT_OBJDouble(VALUE) 1156 //%[NSString stringWithFormat:@"%.*lg", DBL_DIG, VALUE] 1157 //%PDDM-DEFINE TEXT_FORMAT_OBJEnum(VALUE) 1158 //%@(VALUE) 1159 //%PDDM-DEFINE ENUM_TYPEPOD(TYPE) 1160 //%NSNumber * 1161 //%PDDM-DEFINE NEQ_POD(VAL1, VAL2) 1162 //%VAL1 != VAL2 1163 //%PDDM-DEFINE EXTRA_METHODS_POD(KEY_NAME, VALUE_NAME) 1164 // Empty 1165 //%PDDM-DEFINE BOOL_EXTRA_METHODS_POD(KEY_NAME, VALUE_NAME) 1166 // Empty 1167 //%PDDM-DEFINE SERIAL_DATA_FOR_ENTRY_POD(KEY_NAME, VALUE_NAME) 1168 //%SERIAL_DATA_FOR_ENTRY_POD_##VALUE_NAME(KEY_NAME) 1169 //%PDDM-DEFINE SERIAL_DATA_FOR_ENTRY_POD_UInt32(KEY_NAME) 1170 // Empty 1171 //%PDDM-DEFINE SERIAL_DATA_FOR_ENTRY_POD_Int32(KEY_NAME) 1172 // Empty 1173 //%PDDM-DEFINE SERIAL_DATA_FOR_ENTRY_POD_UInt64(KEY_NAME) 1174 // Empty 1175 //%PDDM-DEFINE SERIAL_DATA_FOR_ENTRY_POD_Int64(KEY_NAME) 1176 // Empty 1177 //%PDDM-DEFINE SERIAL_DATA_FOR_ENTRY_POD_Bool(KEY_NAME) 1178 // Empty 1179 //%PDDM-DEFINE SERIAL_DATA_FOR_ENTRY_POD_Float(KEY_NAME) 1180 // Empty 1181 //%PDDM-DEFINE SERIAL_DATA_FOR_ENTRY_POD_Double(KEY_NAME) 1182 // Empty 1183 //%PDDM-DEFINE SERIAL_DATA_FOR_ENTRY_POD_Enum(KEY_NAME) 1184 //%- (NSData *)serializedDataForUnknownValue:(int32_t)value 1185 //% forKey:(GPBGenericValue *)key 1186 //% keyDataType:(GPBDataType)keyDataType { 1187 //% size_t msgSize = ComputeDict##KEY_NAME##FieldSize(key->value##KEY_NAME, kMapKeyFieldNumber, keyDataType); 1188 //% msgSize += ComputeDictEnumFieldSize(value, kMapValueFieldNumber, GPBDataTypeEnum); 1189 //% NSMutableData *data = [NSMutableData dataWithLength:msgSize]; 1190 //% GPBCodedOutputStream *outputStream = [[GPBCodedOutputStream alloc] initWithData:data]; 1191 //% WriteDict##KEY_NAME##Field(outputStream, key->value##KEY_NAME, kMapKeyFieldNumber, keyDataType); 1192 //% WriteDictEnumField(outputStream, value, kMapValueFieldNumber, GPBDataTypeEnum); 1193 //% [outputStream release]; 1194 //% return data; 1195 //%} 1196 //% 1197 //%PDDM-DEFINE GPBVALUE_POD(VALUE_NAME) 1198 //%value##VALUE_NAME 1199 //%PDDM-DEFINE DICTIONARY_VALIDATE_VALUE_POD(VALUE_NAME, EXTRA_INDENT) 1200 // Empty 1201 //%PDDM-DEFINE DICTIONARY_VALIDATE_KEY_POD(KEY_NAME, EXTRA_INDENT) 1202 // Empty 1203 1204 //%PDDM-DEFINE BOOL_DICT_HAS_STORAGE_POD() 1205 //% BOOL _valueSet[2]; 1206 //% 1207 //%PDDM-DEFINE BOOL_DICT_INITS_POD(VALUE_NAME, VALUE_TYPE) 1208 //%- (instancetype)initWithValues:(const VALUE_TYPE [])values 1209 //% forKeys:(const BOOL [])keys 1210 //% count:(NSUInteger)count { 1211 //% self = [super init]; 1212 //% if (self) { 1213 //% for (NSUInteger i = 0; i < count; ++i) { 1214 //% int idx = keys[i] ? 1 : 0; 1215 //% _values[idx] = values[i]; 1216 //% _valueSet[idx] = YES; 1217 //% } 1218 //% } 1219 //% return self; 1220 //%} 1221 //% 1222 //%- (instancetype)initWithDictionary:(GPBBool##VALUE_NAME##Dictionary *)dictionary { 1223 //% self = [self initWithValues:NULL forKeys:NULL count:0]; 1224 //% if (self) { 1225 //% if (dictionary) { 1226 //% for (int i = 0; i < 2; ++i) { 1227 //% if (dictionary->_valueSet[i]) { 1228 //% _values[i] = dictionary->_values[i]; 1229 //% _valueSet[i] = YES; 1230 //% } 1231 //% } 1232 //% } 1233 //% } 1234 //% return self; 1235 //%} 1236 //%PDDM-DEFINE BOOL_DICT_DEALLOCPOD() 1237 //%#if !defined(NS_BLOCK_ASSERTIONS) 1238 //%- (void)dealloc { 1239 //% NSAssert(!_autocreator, 1240 //% @"%@: Autocreator must be cleared before release, autocreator: %@", 1241 //% [self class], _autocreator); 1242 //% [super dealloc]; 1243 //%} 1244 //%#endif // !defined(NS_BLOCK_ASSERTIONS) 1245 //%PDDM-DEFINE BOOL_DICT_W_HASPOD(IDX, REF) 1246 //%BOOL_DICT_HASPOD(IDX, REF) 1247 //%PDDM-DEFINE BOOL_DICT_HASPOD(IDX, REF) 1248 //%REF##_valueSet[IDX] 1249 //%PDDM-DEFINE BOOL_VALUE_FOR_KEY_POD(VALUE_TYPE) 1250 //%- (BOOL)valueForKey:(BOOL)key value:(VALUE_TYPE *)value { 1251 //% int idx = (key ? 1 : 0); 1252 //% if (_valueSet[idx]) { 1253 //% if (value) { 1254 //% *value = _values[idx]; 1255 //% } 1256 //% return YES; 1257 //% } 1258 //% return NO; 1259 //%} 1260 //%PDDM-DEFINE BOOL_SET_GPBVALUE_FOR_KEY_POD(VALUE_NAME, VALUE_TYPE, VisP) 1261 //%- (void)setGPBGenericValue:(GPBGenericValue *)value 1262 //% forGPBGenericValueKey:(GPBGenericValue *)key { 1263 //% int idx = (key->valueBool ? 1 : 0); 1264 //% _values[idx] = value->value##VALUE_NAME; 1265 //% _valueSet[idx] = YES; 1266 //%} 1267 //%PDDM-DEFINE BOOL_DICT_MUTATIONS_POD(VALUE_NAME, VALUE_TYPE) 1268 //%- (void)addEntriesFromDictionary:(GPBBool##VALUE_NAME##Dictionary *)otherDictionary { 1269 //% if (otherDictionary) { 1270 //% for (int i = 0; i < 2; ++i) { 1271 //% if (otherDictionary->_valueSet[i]) { 1272 //% _valueSet[i] = YES; 1273 //% _values[i] = otherDictionary->_values[i]; 1274 //% } 1275 //% } 1276 //% if (_autocreator) { 1277 //% GPBAutocreatedDictionaryModified(_autocreator, self); 1278 //% } 1279 //% } 1280 //%} 1281 //% 1282 //%- (void)setValue:(VALUE_TYPE)value forKey:(BOOL)key { 1283 //% int idx = (key ? 1 : 0); 1284 //% _values[idx] = value; 1285 //% _valueSet[idx] = YES; 1286 //% if (_autocreator) { 1287 //% GPBAutocreatedDictionaryModified(_autocreator, self); 1288 //% } 1289 //%} 1290 //% 1291 //%- (void)removeValueForKey:(BOOL)aKey { 1292 //% _valueSet[aKey ? 1 : 0] = NO; 1293 //%} 1294 //% 1295 //%- (void)removeAll { 1296 //% _valueSet[0] = NO; 1297 //% _valueSet[1] = NO; 1298 //%} 1299 //%PDDM-DEFINE STR_FORMAT_POD(VALUE_NAME) 1300 //%STR_FORMAT_##VALUE_NAME() 1301 //%PDDM-DEFINE STR_FORMAT_UInt32() 1302 //%%u 1303 //%PDDM-DEFINE STR_FORMAT_Int32() 1304 //%%d 1305 //%PDDM-DEFINE STR_FORMAT_UInt64() 1306 //%%llu 1307 //%PDDM-DEFINE STR_FORMAT_Int64() 1308 //%%lld 1309 //%PDDM-DEFINE STR_FORMAT_Bool() 1310 //%%d 1311 //%PDDM-DEFINE STR_FORMAT_Float() 1312 //%%f 1313 //%PDDM-DEFINE STR_FORMAT_Double() 1314 //%%lf 1315 1316 // 1317 // Helpers for Objects 1318 // 1319 1320 //%PDDM-DEFINE VALUE_FOR_KEY_OBJECT(KEY_TYPE, VALUE_NAME, VALUE_TYPE, KHELPER) 1321 //%- (VALUE_TYPE)objectForKey:(KEY_TYPE)key { 1322 //% VALUE_TYPE result = [_dictionary objectForKey:WRAPPED##KHELPER(key)]; 1323 //% return result; 1324 //%} 1325 //%PDDM-DEFINE WRAPPEDOBJECT(VALUE) 1326 //%VALUE 1327 //%PDDM-DEFINE UNWRAPString(VALUE) 1328 //%VALUE 1329 //%PDDM-DEFINE UNWRAPObject(VALUE) 1330 //%VALUE 1331 //%PDDM-DEFINE TEXT_FORMAT_OBJString(VALUE) 1332 //%VALUE 1333 //%PDDM-DEFINE TEXT_FORMAT_OBJObject(VALUE) 1334 //%VALUE 1335 //%PDDM-DEFINE ENUM_TYPEOBJECT(TYPE) 1336 //%ENUM_TYPEOBJECT_##TYPE() 1337 //%PDDM-DEFINE ENUM_TYPEOBJECT_NSString() 1338 //%NSString * 1339 //%PDDM-DEFINE ENUM_TYPEOBJECT_id() 1340 //%id ## 1341 //%PDDM-DEFINE NEQ_OBJECT(VAL1, VAL2) 1342 //%![VAL1 isEqual:VAL2] 1343 //%PDDM-DEFINE EXTRA_METHODS_OBJECT(KEY_NAME, VALUE_NAME) 1344 //%- (BOOL)isInitialized { 1345 //% for (GPBMessage *msg in [_dictionary objectEnumerator]) { 1346 //% if (!msg.initialized) { 1347 //% return NO; 1348 //% } 1349 //% } 1350 //% return YES; 1351 //%} 1352 //% 1353 //%- (instancetype)deepCopyWithZone:(NSZone *)zone { 1354 //% GPB##KEY_NAME##VALUE_NAME##Dictionary *newDict = 1355 //% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] init]; 1356 //% [_dictionary enumerateKeysAndObjectsUsingBlock:^(id aKey, 1357 //% GPBMessage *msg, 1358 //% BOOL *stop) { 1359 //% #pragma unused(stop) 1360 //% GPBMessage *copiedMsg = [msg copyWithZone:zone]; 1361 //% [newDict->_dictionary setObject:copiedMsg forKey:aKey]; 1362 //% [copiedMsg release]; 1363 //% }]; 1364 //% return newDict; 1365 //%} 1366 //% 1367 //% 1368 //%PDDM-DEFINE BOOL_EXTRA_METHODS_OBJECT(KEY_NAME, VALUE_NAME) 1369 //%- (BOOL)isInitialized { 1370 //% if (_values[0] && ![_values[0] isInitialized]) { 1371 //% return NO; 1372 //% } 1373 //% if (_values[1] && ![_values[1] isInitialized]) { 1374 //% return NO; 1375 //% } 1376 //% return YES; 1377 //%} 1378 //% 1379 //%- (instancetype)deepCopyWithZone:(NSZone *)zone { 1380 //% GPB##KEY_NAME##VALUE_NAME##Dictionary *newDict = 1381 //% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] init]; 1382 //% for (int i = 0; i < 2; ++i) { 1383 //% if (_values[i] != nil) { 1384 //% newDict->_values[i] = [_values[i] copyWithZone:zone]; 1385 //% } 1386 //% } 1387 //% return newDict; 1388 //%} 1389 //% 1390 //% 1391 //%PDDM-DEFINE SERIAL_DATA_FOR_ENTRY_OBJECT(KEY_NAME, VALUE_NAME) 1392 // Empty 1393 //%PDDM-DEFINE GPBVALUE_OBJECT(VALUE_NAME) 1394 //%valueString 1395 //%PDDM-DEFINE DICTIONARY_VALIDATE_VALUE_OBJECT(VALUE_NAME, EXTRA_INDENT) 1396 //%##EXTRA_INDENT$S## if (!##VALUE_NAME) { 1397 //%##EXTRA_INDENT$S## [NSException raise:NSInvalidArgumentException 1398 //%##EXTRA_INDENT$S## format:@"Attempting to add nil object to a Dictionary"]; 1399 //%##EXTRA_INDENT$S## } 1400 //% 1401 //%PDDM-DEFINE DICTIONARY_VALIDATE_KEY_OBJECT(KEY_NAME, EXTRA_INDENT) 1402 //%##EXTRA_INDENT$S## if (!##KEY_NAME) { 1403 //%##EXTRA_INDENT$S## [NSException raise:NSInvalidArgumentException 1404 //%##EXTRA_INDENT$S## format:@"Attempting to add nil key to a Dictionary"]; 1405 //%##EXTRA_INDENT$S## } 1406 //% 1407 1408 //%PDDM-DEFINE BOOL_DICT_HAS_STORAGE_OBJECT() 1409 // Empty 1410 //%PDDM-DEFINE BOOL_DICT_INITS_OBJECT(VALUE_NAME, VALUE_TYPE) 1411 //%- (instancetype)initWithObjects:(const VALUE_TYPE [])objects 1412 //% forKeys:(const BOOL [])keys 1413 //% count:(NSUInteger)count { 1414 //% self = [super init]; 1415 //% if (self) { 1416 //% for (NSUInteger i = 0; i < count; ++i) { 1417 //% if (!objects[i]) { 1418 //% [NSException raise:NSInvalidArgumentException 1419 //% format:@"Attempting to add nil object to a Dictionary"]; 1420 //% } 1421 //% int idx = keys[i] ? 1 : 0; 1422 //% [_values[idx] release]; 1423 //% _values[idx] = (VALUE_TYPE)[objects[i] retain]; 1424 //% } 1425 //% } 1426 //% return self; 1427 //%} 1428 //% 1429 //%- (instancetype)initWithDictionary:(GPBBool##VALUE_NAME##Dictionary *)dictionary { 1430 //% self = [self initWithObjects:NULL forKeys:NULL count:0]; 1431 //% if (self) { 1432 //% if (dictionary) { 1433 //% _values[0] = [dictionary->_values[0] retain]; 1434 //% _values[1] = [dictionary->_values[1] retain]; 1435 //% } 1436 //% } 1437 //% return self; 1438 //%} 1439 //%PDDM-DEFINE BOOL_DICT_DEALLOCOBJECT() 1440 //%- (void)dealloc { 1441 //% NSAssert(!_autocreator, 1442 //% @"%@: Autocreator must be cleared before release, autocreator: %@", 1443 //% [self class], _autocreator); 1444 //% [_values[0] release]; 1445 //% [_values[1] release]; 1446 //% [super dealloc]; 1447 //%} 1448 //%PDDM-DEFINE BOOL_DICT_W_HASOBJECT(IDX, REF) 1449 //%(BOOL_DICT_HASOBJECT(IDX, REF)) 1450 //%PDDM-DEFINE BOOL_DICT_HASOBJECT(IDX, REF) 1451 //%REF##_values[IDX] != nil 1452 //%PDDM-DEFINE BOOL_VALUE_FOR_KEY_OBJECT(VALUE_TYPE) 1453 //%- (VALUE_TYPE)objectForKey:(BOOL)key { 1454 //% return _values[key ? 1 : 0]; 1455 //%} 1456 //%PDDM-DEFINE BOOL_SET_GPBVALUE_FOR_KEY_OBJECT(VALUE_NAME, VALUE_TYPE, VisP) 1457 //%- (void)setGPBGenericValue:(GPBGenericValue *)value 1458 //% forGPBGenericValueKey:(GPBGenericValue *)key { 1459 //% int idx = (key->valueBool ? 1 : 0); 1460 //% [_values[idx] release]; 1461 //% _values[idx] = [value->valueString retain]; 1462 //%} 1463 1464 //%PDDM-DEFINE BOOL_DICT_MUTATIONS_OBJECT(VALUE_NAME, VALUE_TYPE) 1465 //%- (void)addEntriesFromDictionary:(GPBBool##VALUE_NAME##Dictionary *)otherDictionary { 1466 //% if (otherDictionary) { 1467 //% for (int i = 0; i < 2; ++i) { 1468 //% if (otherDictionary->_values[i] != nil) { 1469 //% [_values[i] release]; 1470 //% _values[i] = [otherDictionary->_values[i] retain]; 1471 //% } 1472 //% } 1473 //% if (_autocreator) { 1474 //% GPBAutocreatedDictionaryModified(_autocreator, self); 1475 //% } 1476 //% } 1477 //%} 1478 //% 1479 //%- (void)setObject:(VALUE_TYPE)object forKey:(BOOL)key { 1480 //% if (!object) { 1481 //% [NSException raise:NSInvalidArgumentException 1482 //% format:@"Attempting to add nil object to a Dictionary"]; 1483 //% } 1484 //% int idx = (key ? 1 : 0); 1485 //% [_values[idx] release]; 1486 //% _values[idx] = [object retain]; 1487 //% if (_autocreator) { 1488 //% GPBAutocreatedDictionaryModified(_autocreator, self); 1489 //% } 1490 //%} 1491 //% 1492 //%- (void)removeObjectForKey:(BOOL)aKey { 1493 //% int idx = (aKey ? 1 : 0); 1494 //% [_values[idx] release]; 1495 //% _values[idx] = nil; 1496 //%} 1497 //% 1498 //%- (void)removeAll { 1499 //% for (int i = 0; i < 2; ++i) { 1500 //% [_values[i] release]; 1501 //% _values[i] = nil; 1502 //% } 1503 //%} 1504 //%PDDM-DEFINE STR_FORMAT_OBJECT(VALUE_NAME) 1505 //%%@ 1506 1507 1508 //%PDDM-EXPAND DICTIONARY_IMPL_FOR_POD_KEY(UInt32, uint32_t) 1509 // This block of code is generated, do not edit it directly. 1510 1511 #pragma mark - UInt32 -> UInt32 1512 1513 @implementation GPBUInt32UInt32Dictionary { 1514 @package 1515 NSMutableDictionary *_dictionary; 1516 } 1517 1518 + (instancetype)dictionary { 1519 return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; 1520 } 1521 1522 + (instancetype)dictionaryWithValue:(uint32_t)value 1523 forKey:(uint32_t)key { 1524 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 1525 // on to get the type correct. 1526 return [[(GPBUInt32UInt32Dictionary*)[self alloc] initWithValues:&value 1527 forKeys:&key 1528 count:1] autorelease]; 1529 } 1530 1531 + (instancetype)dictionaryWithValues:(const uint32_t [])values 1532 forKeys:(const uint32_t [])keys 1533 count:(NSUInteger)count { 1534 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 1535 // on to get the type correct. 1536 return [[(GPBUInt32UInt32Dictionary*)[self alloc] initWithValues:values 1537 forKeys:keys 1538 count:count] autorelease]; 1539 } 1540 1541 + (instancetype)dictionaryWithDictionary:(GPBUInt32UInt32Dictionary *)dictionary { 1542 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 1543 // on to get the type correct. 1544 return [[(GPBUInt32UInt32Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 1545 } 1546 1547 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 1548 return [[[self alloc] initWithCapacity:numItems] autorelease]; 1549 } 1550 1551 - (instancetype)init { 1552 return [self initWithValues:NULL forKeys:NULL count:0]; 1553 } 1554 1555 - (instancetype)initWithValues:(const uint32_t [])values 1556 forKeys:(const uint32_t [])keys 1557 count:(NSUInteger)count { 1558 self = [super init]; 1559 if (self) { 1560 _dictionary = [[NSMutableDictionary alloc] init]; 1561 if (count && values && keys) { 1562 for (NSUInteger i = 0; i < count; ++i) { 1563 [_dictionary setObject:@(values[i]) forKey:@(keys[i])]; 1564 } 1565 } 1566 } 1567 return self; 1568 } 1569 1570 - (instancetype)initWithDictionary:(GPBUInt32UInt32Dictionary *)dictionary { 1571 self = [self initWithValues:NULL forKeys:NULL count:0]; 1572 if (self) { 1573 if (dictionary) { 1574 [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 1575 } 1576 } 1577 return self; 1578 } 1579 1580 - (instancetype)initWithCapacity:(NSUInteger)numItems { 1581 #pragma unused(numItems) 1582 return [self initWithValues:NULL forKeys:NULL count:0]; 1583 } 1584 1585 - (void)dealloc { 1586 NSAssert(!_autocreator, 1587 @"%@: Autocreator must be cleared before release, autocreator: %@", 1588 [self class], _autocreator); 1589 [_dictionary release]; 1590 [super dealloc]; 1591 } 1592 1593 - (instancetype)copyWithZone:(NSZone *)zone { 1594 return [[GPBUInt32UInt32Dictionary allocWithZone:zone] initWithDictionary:self]; 1595 } 1596 1597 - (BOOL)isEqual:(GPBUInt32UInt32Dictionary *)other { 1598 if (self == other) { 1599 return YES; 1600 } 1601 if (![other isKindOfClass:[GPBUInt32UInt32Dictionary class]]) { 1602 return NO; 1603 } 1604 return [_dictionary isEqual:other->_dictionary]; 1605 } 1606 1607 - (NSUInteger)hash { 1608 return _dictionary.count; 1609 } 1610 1611 - (NSString *)description { 1612 return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 1613 } 1614 1615 - (NSUInteger)count { 1616 return _dictionary.count; 1617 } 1618 1619 - (void)enumerateKeysAndValuesUsingBlock: 1620 (void (^)(uint32_t key, uint32_t value, BOOL *stop))block { 1621 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 1622 NSNumber *aValue, 1623 BOOL *stop) { 1624 block([aKey unsignedIntValue], [aValue unsignedIntValue], stop); 1625 }]; 1626 } 1627 1628 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 1629 NSUInteger count = _dictionary.count; 1630 if (count == 0) { 1631 return 0; 1632 } 1633 1634 GPBDataType valueDataType = GPBGetFieldDataType(field); 1635 GPBDataType keyDataType = field.mapKeyDataType; 1636 __block size_t result = 0; 1637 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 1638 NSNumber *aValue, 1639 BOOL *stop) { 1640 #pragma unused(stop) 1641 size_t msgSize = ComputeDictUInt32FieldSize([aKey unsignedIntValue], kMapKeyFieldNumber, keyDataType); 1642 msgSize += ComputeDictUInt32FieldSize([aValue unsignedIntValue], kMapValueFieldNumber, valueDataType); 1643 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 1644 }]; 1645 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 1646 result += tagSize * count; 1647 return result; 1648 } 1649 1650 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 1651 asField:(GPBFieldDescriptor *)field { 1652 GPBDataType valueDataType = GPBGetFieldDataType(field); 1653 GPBDataType keyDataType = field.mapKeyDataType; 1654 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 1655 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 1656 NSNumber *aValue, 1657 BOOL *stop) { 1658 #pragma unused(stop) 1659 // Write the tag. 1660 [outputStream writeInt32NoTag:tag]; 1661 // Write the size of the message. 1662 size_t msgSize = ComputeDictUInt32FieldSize([aKey unsignedIntValue], kMapKeyFieldNumber, keyDataType); 1663 msgSize += ComputeDictUInt32FieldSize([aValue unsignedIntValue], kMapValueFieldNumber, valueDataType); 1664 [outputStream writeInt32NoTag:(int32_t)msgSize]; 1665 // Write the fields. 1666 WriteDictUInt32Field(outputStream, [aKey unsignedIntValue], kMapKeyFieldNumber, keyDataType); 1667 WriteDictUInt32Field(outputStream, [aValue unsignedIntValue], kMapValueFieldNumber, valueDataType); 1668 }]; 1669 } 1670 1671 - (void)setGPBGenericValue:(GPBGenericValue *)value 1672 forGPBGenericValueKey:(GPBGenericValue *)key { 1673 [_dictionary setObject:@(value->valueUInt32) forKey:@(key->valueUInt32)]; 1674 } 1675 1676 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 1677 [self enumerateKeysAndValuesUsingBlock:^(uint32_t key, uint32_t value, BOOL *stop) { 1678 #pragma unused(stop) 1679 block([NSString stringWithFormat:@"%u", key], [NSString stringWithFormat:@"%u", value]); 1680 }]; 1681 } 1682 1683 - (BOOL)valueForKey:(uint32_t)key value:(uint32_t *)value { 1684 NSNumber *wrapped = [_dictionary objectForKey:@(key)]; 1685 if (wrapped && value) { 1686 *value = [wrapped unsignedIntValue]; 1687 } 1688 return (wrapped != NULL); 1689 } 1690 1691 - (void)addEntriesFromDictionary:(GPBUInt32UInt32Dictionary *)otherDictionary { 1692 if (otherDictionary) { 1693 [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 1694 if (_autocreator) { 1695 GPBAutocreatedDictionaryModified(_autocreator, self); 1696 } 1697 } 1698 } 1699 1700 - (void)setValue:(uint32_t)value forKey:(uint32_t)key { 1701 [_dictionary setObject:@(value) forKey:@(key)]; 1702 if (_autocreator) { 1703 GPBAutocreatedDictionaryModified(_autocreator, self); 1704 } 1705 } 1706 1707 - (void)removeValueForKey:(uint32_t)aKey { 1708 [_dictionary removeObjectForKey:@(aKey)]; 1709 } 1710 1711 - (void)removeAll { 1712 [_dictionary removeAllObjects]; 1713 } 1714 1715 @end 1716 1717 #pragma mark - UInt32 -> Int32 1718 1719 @implementation GPBUInt32Int32Dictionary { 1720 @package 1721 NSMutableDictionary *_dictionary; 1722 } 1723 1724 + (instancetype)dictionary { 1725 return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; 1726 } 1727 1728 + (instancetype)dictionaryWithValue:(int32_t)value 1729 forKey:(uint32_t)key { 1730 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 1731 // on to get the type correct. 1732 return [[(GPBUInt32Int32Dictionary*)[self alloc] initWithValues:&value 1733 forKeys:&key 1734 count:1] autorelease]; 1735 } 1736 1737 + (instancetype)dictionaryWithValues:(const int32_t [])values 1738 forKeys:(const uint32_t [])keys 1739 count:(NSUInteger)count { 1740 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 1741 // on to get the type correct. 1742 return [[(GPBUInt32Int32Dictionary*)[self alloc] initWithValues:values 1743 forKeys:keys 1744 count:count] autorelease]; 1745 } 1746 1747 + (instancetype)dictionaryWithDictionary:(GPBUInt32Int32Dictionary *)dictionary { 1748 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 1749 // on to get the type correct. 1750 return [[(GPBUInt32Int32Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 1751 } 1752 1753 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 1754 return [[[self alloc] initWithCapacity:numItems] autorelease]; 1755 } 1756 1757 - (instancetype)init { 1758 return [self initWithValues:NULL forKeys:NULL count:0]; 1759 } 1760 1761 - (instancetype)initWithValues:(const int32_t [])values 1762 forKeys:(const uint32_t [])keys 1763 count:(NSUInteger)count { 1764 self = [super init]; 1765 if (self) { 1766 _dictionary = [[NSMutableDictionary alloc] init]; 1767 if (count && values && keys) { 1768 for (NSUInteger i = 0; i < count; ++i) { 1769 [_dictionary setObject:@(values[i]) forKey:@(keys[i])]; 1770 } 1771 } 1772 } 1773 return self; 1774 } 1775 1776 - (instancetype)initWithDictionary:(GPBUInt32Int32Dictionary *)dictionary { 1777 self = [self initWithValues:NULL forKeys:NULL count:0]; 1778 if (self) { 1779 if (dictionary) { 1780 [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 1781 } 1782 } 1783 return self; 1784 } 1785 1786 - (instancetype)initWithCapacity:(NSUInteger)numItems { 1787 #pragma unused(numItems) 1788 return [self initWithValues:NULL forKeys:NULL count:0]; 1789 } 1790 1791 - (void)dealloc { 1792 NSAssert(!_autocreator, 1793 @"%@: Autocreator must be cleared before release, autocreator: %@", 1794 [self class], _autocreator); 1795 [_dictionary release]; 1796 [super dealloc]; 1797 } 1798 1799 - (instancetype)copyWithZone:(NSZone *)zone { 1800 return [[GPBUInt32Int32Dictionary allocWithZone:zone] initWithDictionary:self]; 1801 } 1802 1803 - (BOOL)isEqual:(GPBUInt32Int32Dictionary *)other { 1804 if (self == other) { 1805 return YES; 1806 } 1807 if (![other isKindOfClass:[GPBUInt32Int32Dictionary class]]) { 1808 return NO; 1809 } 1810 return [_dictionary isEqual:other->_dictionary]; 1811 } 1812 1813 - (NSUInteger)hash { 1814 return _dictionary.count; 1815 } 1816 1817 - (NSString *)description { 1818 return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 1819 } 1820 1821 - (NSUInteger)count { 1822 return _dictionary.count; 1823 } 1824 1825 - (void)enumerateKeysAndValuesUsingBlock: 1826 (void (^)(uint32_t key, int32_t value, BOOL *stop))block { 1827 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 1828 NSNumber *aValue, 1829 BOOL *stop) { 1830 block([aKey unsignedIntValue], [aValue intValue], stop); 1831 }]; 1832 } 1833 1834 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 1835 NSUInteger count = _dictionary.count; 1836 if (count == 0) { 1837 return 0; 1838 } 1839 1840 GPBDataType valueDataType = GPBGetFieldDataType(field); 1841 GPBDataType keyDataType = field.mapKeyDataType; 1842 __block size_t result = 0; 1843 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 1844 NSNumber *aValue, 1845 BOOL *stop) { 1846 #pragma unused(stop) 1847 size_t msgSize = ComputeDictUInt32FieldSize([aKey unsignedIntValue], kMapKeyFieldNumber, keyDataType); 1848 msgSize += ComputeDictInt32FieldSize([aValue intValue], kMapValueFieldNumber, valueDataType); 1849 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 1850 }]; 1851 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 1852 result += tagSize * count; 1853 return result; 1854 } 1855 1856 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 1857 asField:(GPBFieldDescriptor *)field { 1858 GPBDataType valueDataType = GPBGetFieldDataType(field); 1859 GPBDataType keyDataType = field.mapKeyDataType; 1860 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 1861 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 1862 NSNumber *aValue, 1863 BOOL *stop) { 1864 #pragma unused(stop) 1865 // Write the tag. 1866 [outputStream writeInt32NoTag:tag]; 1867 // Write the size of the message. 1868 size_t msgSize = ComputeDictUInt32FieldSize([aKey unsignedIntValue], kMapKeyFieldNumber, keyDataType); 1869 msgSize += ComputeDictInt32FieldSize([aValue intValue], kMapValueFieldNumber, valueDataType); 1870 [outputStream writeInt32NoTag:(int32_t)msgSize]; 1871 // Write the fields. 1872 WriteDictUInt32Field(outputStream, [aKey unsignedIntValue], kMapKeyFieldNumber, keyDataType); 1873 WriteDictInt32Field(outputStream, [aValue intValue], kMapValueFieldNumber, valueDataType); 1874 }]; 1875 } 1876 1877 - (void)setGPBGenericValue:(GPBGenericValue *)value 1878 forGPBGenericValueKey:(GPBGenericValue *)key { 1879 [_dictionary setObject:@(value->valueInt32) forKey:@(key->valueUInt32)]; 1880 } 1881 1882 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 1883 [self enumerateKeysAndValuesUsingBlock:^(uint32_t key, int32_t value, BOOL *stop) { 1884 #pragma unused(stop) 1885 block([NSString stringWithFormat:@"%u", key], [NSString stringWithFormat:@"%d", value]); 1886 }]; 1887 } 1888 1889 - (BOOL)valueForKey:(uint32_t)key value:(int32_t *)value { 1890 NSNumber *wrapped = [_dictionary objectForKey:@(key)]; 1891 if (wrapped && value) { 1892 *value = [wrapped intValue]; 1893 } 1894 return (wrapped != NULL); 1895 } 1896 1897 - (void)addEntriesFromDictionary:(GPBUInt32Int32Dictionary *)otherDictionary { 1898 if (otherDictionary) { 1899 [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 1900 if (_autocreator) { 1901 GPBAutocreatedDictionaryModified(_autocreator, self); 1902 } 1903 } 1904 } 1905 1906 - (void)setValue:(int32_t)value forKey:(uint32_t)key { 1907 [_dictionary setObject:@(value) forKey:@(key)]; 1908 if (_autocreator) { 1909 GPBAutocreatedDictionaryModified(_autocreator, self); 1910 } 1911 } 1912 1913 - (void)removeValueForKey:(uint32_t)aKey { 1914 [_dictionary removeObjectForKey:@(aKey)]; 1915 } 1916 1917 - (void)removeAll { 1918 [_dictionary removeAllObjects]; 1919 } 1920 1921 @end 1922 1923 #pragma mark - UInt32 -> UInt64 1924 1925 @implementation GPBUInt32UInt64Dictionary { 1926 @package 1927 NSMutableDictionary *_dictionary; 1928 } 1929 1930 + (instancetype)dictionary { 1931 return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; 1932 } 1933 1934 + (instancetype)dictionaryWithValue:(uint64_t)value 1935 forKey:(uint32_t)key { 1936 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 1937 // on to get the type correct. 1938 return [[(GPBUInt32UInt64Dictionary*)[self alloc] initWithValues:&value 1939 forKeys:&key 1940 count:1] autorelease]; 1941 } 1942 1943 + (instancetype)dictionaryWithValues:(const uint64_t [])values 1944 forKeys:(const uint32_t [])keys 1945 count:(NSUInteger)count { 1946 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 1947 // on to get the type correct. 1948 return [[(GPBUInt32UInt64Dictionary*)[self alloc] initWithValues:values 1949 forKeys:keys 1950 count:count] autorelease]; 1951 } 1952 1953 + (instancetype)dictionaryWithDictionary:(GPBUInt32UInt64Dictionary *)dictionary { 1954 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 1955 // on to get the type correct. 1956 return [[(GPBUInt32UInt64Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 1957 } 1958 1959 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 1960 return [[[self alloc] initWithCapacity:numItems] autorelease]; 1961 } 1962 1963 - (instancetype)init { 1964 return [self initWithValues:NULL forKeys:NULL count:0]; 1965 } 1966 1967 - (instancetype)initWithValues:(const uint64_t [])values 1968 forKeys:(const uint32_t [])keys 1969 count:(NSUInteger)count { 1970 self = [super init]; 1971 if (self) { 1972 _dictionary = [[NSMutableDictionary alloc] init]; 1973 if (count && values && keys) { 1974 for (NSUInteger i = 0; i < count; ++i) { 1975 [_dictionary setObject:@(values[i]) forKey:@(keys[i])]; 1976 } 1977 } 1978 } 1979 return self; 1980 } 1981 1982 - (instancetype)initWithDictionary:(GPBUInt32UInt64Dictionary *)dictionary { 1983 self = [self initWithValues:NULL forKeys:NULL count:0]; 1984 if (self) { 1985 if (dictionary) { 1986 [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 1987 } 1988 } 1989 return self; 1990 } 1991 1992 - (instancetype)initWithCapacity:(NSUInteger)numItems { 1993 #pragma unused(numItems) 1994 return [self initWithValues:NULL forKeys:NULL count:0]; 1995 } 1996 1997 - (void)dealloc { 1998 NSAssert(!_autocreator, 1999 @"%@: Autocreator must be cleared before release, autocreator: %@", 2000 [self class], _autocreator); 2001 [_dictionary release]; 2002 [super dealloc]; 2003 } 2004 2005 - (instancetype)copyWithZone:(NSZone *)zone { 2006 return [[GPBUInt32UInt64Dictionary allocWithZone:zone] initWithDictionary:self]; 2007 } 2008 2009 - (BOOL)isEqual:(GPBUInt32UInt64Dictionary *)other { 2010 if (self == other) { 2011 return YES; 2012 } 2013 if (![other isKindOfClass:[GPBUInt32UInt64Dictionary class]]) { 2014 return NO; 2015 } 2016 return [_dictionary isEqual:other->_dictionary]; 2017 } 2018 2019 - (NSUInteger)hash { 2020 return _dictionary.count; 2021 } 2022 2023 - (NSString *)description { 2024 return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 2025 } 2026 2027 - (NSUInteger)count { 2028 return _dictionary.count; 2029 } 2030 2031 - (void)enumerateKeysAndValuesUsingBlock: 2032 (void (^)(uint32_t key, uint64_t value, BOOL *stop))block { 2033 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 2034 NSNumber *aValue, 2035 BOOL *stop) { 2036 block([aKey unsignedIntValue], [aValue unsignedLongLongValue], stop); 2037 }]; 2038 } 2039 2040 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 2041 NSUInteger count = _dictionary.count; 2042 if (count == 0) { 2043 return 0; 2044 } 2045 2046 GPBDataType valueDataType = GPBGetFieldDataType(field); 2047 GPBDataType keyDataType = field.mapKeyDataType; 2048 __block size_t result = 0; 2049 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 2050 NSNumber *aValue, 2051 BOOL *stop) { 2052 #pragma unused(stop) 2053 size_t msgSize = ComputeDictUInt32FieldSize([aKey unsignedIntValue], kMapKeyFieldNumber, keyDataType); 2054 msgSize += ComputeDictUInt64FieldSize([aValue unsignedLongLongValue], kMapValueFieldNumber, valueDataType); 2055 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 2056 }]; 2057 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 2058 result += tagSize * count; 2059 return result; 2060 } 2061 2062 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 2063 asField:(GPBFieldDescriptor *)field { 2064 GPBDataType valueDataType = GPBGetFieldDataType(field); 2065 GPBDataType keyDataType = field.mapKeyDataType; 2066 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 2067 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 2068 NSNumber *aValue, 2069 BOOL *stop) { 2070 #pragma unused(stop) 2071 // Write the tag. 2072 [outputStream writeInt32NoTag:tag]; 2073 // Write the size of the message. 2074 size_t msgSize = ComputeDictUInt32FieldSize([aKey unsignedIntValue], kMapKeyFieldNumber, keyDataType); 2075 msgSize += ComputeDictUInt64FieldSize([aValue unsignedLongLongValue], kMapValueFieldNumber, valueDataType); 2076 [outputStream writeInt32NoTag:(int32_t)msgSize]; 2077 // Write the fields. 2078 WriteDictUInt32Field(outputStream, [aKey unsignedIntValue], kMapKeyFieldNumber, keyDataType); 2079 WriteDictUInt64Field(outputStream, [aValue unsignedLongLongValue], kMapValueFieldNumber, valueDataType); 2080 }]; 2081 } 2082 2083 - (void)setGPBGenericValue:(GPBGenericValue *)value 2084 forGPBGenericValueKey:(GPBGenericValue *)key { 2085 [_dictionary setObject:@(value->valueUInt64) forKey:@(key->valueUInt32)]; 2086 } 2087 2088 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 2089 [self enumerateKeysAndValuesUsingBlock:^(uint32_t key, uint64_t value, BOOL *stop) { 2090 #pragma unused(stop) 2091 block([NSString stringWithFormat:@"%u", key], [NSString stringWithFormat:@"%llu", value]); 2092 }]; 2093 } 2094 2095 - (BOOL)valueForKey:(uint32_t)key value:(uint64_t *)value { 2096 NSNumber *wrapped = [_dictionary objectForKey:@(key)]; 2097 if (wrapped && value) { 2098 *value = [wrapped unsignedLongLongValue]; 2099 } 2100 return (wrapped != NULL); 2101 } 2102 2103 - (void)addEntriesFromDictionary:(GPBUInt32UInt64Dictionary *)otherDictionary { 2104 if (otherDictionary) { 2105 [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 2106 if (_autocreator) { 2107 GPBAutocreatedDictionaryModified(_autocreator, self); 2108 } 2109 } 2110 } 2111 2112 - (void)setValue:(uint64_t)value forKey:(uint32_t)key { 2113 [_dictionary setObject:@(value) forKey:@(key)]; 2114 if (_autocreator) { 2115 GPBAutocreatedDictionaryModified(_autocreator, self); 2116 } 2117 } 2118 2119 - (void)removeValueForKey:(uint32_t)aKey { 2120 [_dictionary removeObjectForKey:@(aKey)]; 2121 } 2122 2123 - (void)removeAll { 2124 [_dictionary removeAllObjects]; 2125 } 2126 2127 @end 2128 2129 #pragma mark - UInt32 -> Int64 2130 2131 @implementation GPBUInt32Int64Dictionary { 2132 @package 2133 NSMutableDictionary *_dictionary; 2134 } 2135 2136 + (instancetype)dictionary { 2137 return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; 2138 } 2139 2140 + (instancetype)dictionaryWithValue:(int64_t)value 2141 forKey:(uint32_t)key { 2142 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 2143 // on to get the type correct. 2144 return [[(GPBUInt32Int64Dictionary*)[self alloc] initWithValues:&value 2145 forKeys:&key 2146 count:1] autorelease]; 2147 } 2148 2149 + (instancetype)dictionaryWithValues:(const int64_t [])values 2150 forKeys:(const uint32_t [])keys 2151 count:(NSUInteger)count { 2152 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 2153 // on to get the type correct. 2154 return [[(GPBUInt32Int64Dictionary*)[self alloc] initWithValues:values 2155 forKeys:keys 2156 count:count] autorelease]; 2157 } 2158 2159 + (instancetype)dictionaryWithDictionary:(GPBUInt32Int64Dictionary *)dictionary { 2160 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 2161 // on to get the type correct. 2162 return [[(GPBUInt32Int64Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 2163 } 2164 2165 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 2166 return [[[self alloc] initWithCapacity:numItems] autorelease]; 2167 } 2168 2169 - (instancetype)init { 2170 return [self initWithValues:NULL forKeys:NULL count:0]; 2171 } 2172 2173 - (instancetype)initWithValues:(const int64_t [])values 2174 forKeys:(const uint32_t [])keys 2175 count:(NSUInteger)count { 2176 self = [super init]; 2177 if (self) { 2178 _dictionary = [[NSMutableDictionary alloc] init]; 2179 if (count && values && keys) { 2180 for (NSUInteger i = 0; i < count; ++i) { 2181 [_dictionary setObject:@(values[i]) forKey:@(keys[i])]; 2182 } 2183 } 2184 } 2185 return self; 2186 } 2187 2188 - (instancetype)initWithDictionary:(GPBUInt32Int64Dictionary *)dictionary { 2189 self = [self initWithValues:NULL forKeys:NULL count:0]; 2190 if (self) { 2191 if (dictionary) { 2192 [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 2193 } 2194 } 2195 return self; 2196 } 2197 2198 - (instancetype)initWithCapacity:(NSUInteger)numItems { 2199 #pragma unused(numItems) 2200 return [self initWithValues:NULL forKeys:NULL count:0]; 2201 } 2202 2203 - (void)dealloc { 2204 NSAssert(!_autocreator, 2205 @"%@: Autocreator must be cleared before release, autocreator: %@", 2206 [self class], _autocreator); 2207 [_dictionary release]; 2208 [super dealloc]; 2209 } 2210 2211 - (instancetype)copyWithZone:(NSZone *)zone { 2212 return [[GPBUInt32Int64Dictionary allocWithZone:zone] initWithDictionary:self]; 2213 } 2214 2215 - (BOOL)isEqual:(GPBUInt32Int64Dictionary *)other { 2216 if (self == other) { 2217 return YES; 2218 } 2219 if (![other isKindOfClass:[GPBUInt32Int64Dictionary class]]) { 2220 return NO; 2221 } 2222 return [_dictionary isEqual:other->_dictionary]; 2223 } 2224 2225 - (NSUInteger)hash { 2226 return _dictionary.count; 2227 } 2228 2229 - (NSString *)description { 2230 return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 2231 } 2232 2233 - (NSUInteger)count { 2234 return _dictionary.count; 2235 } 2236 2237 - (void)enumerateKeysAndValuesUsingBlock: 2238 (void (^)(uint32_t key, int64_t value, BOOL *stop))block { 2239 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 2240 NSNumber *aValue, 2241 BOOL *stop) { 2242 block([aKey unsignedIntValue], [aValue longLongValue], stop); 2243 }]; 2244 } 2245 2246 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 2247 NSUInteger count = _dictionary.count; 2248 if (count == 0) { 2249 return 0; 2250 } 2251 2252 GPBDataType valueDataType = GPBGetFieldDataType(field); 2253 GPBDataType keyDataType = field.mapKeyDataType; 2254 __block size_t result = 0; 2255 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 2256 NSNumber *aValue, 2257 BOOL *stop) { 2258 #pragma unused(stop) 2259 size_t msgSize = ComputeDictUInt32FieldSize([aKey unsignedIntValue], kMapKeyFieldNumber, keyDataType); 2260 msgSize += ComputeDictInt64FieldSize([aValue longLongValue], kMapValueFieldNumber, valueDataType); 2261 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 2262 }]; 2263 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 2264 result += tagSize * count; 2265 return result; 2266 } 2267 2268 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 2269 asField:(GPBFieldDescriptor *)field { 2270 GPBDataType valueDataType = GPBGetFieldDataType(field); 2271 GPBDataType keyDataType = field.mapKeyDataType; 2272 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 2273 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 2274 NSNumber *aValue, 2275 BOOL *stop) { 2276 #pragma unused(stop) 2277 // Write the tag. 2278 [outputStream writeInt32NoTag:tag]; 2279 // Write the size of the message. 2280 size_t msgSize = ComputeDictUInt32FieldSize([aKey unsignedIntValue], kMapKeyFieldNumber, keyDataType); 2281 msgSize += ComputeDictInt64FieldSize([aValue longLongValue], kMapValueFieldNumber, valueDataType); 2282 [outputStream writeInt32NoTag:(int32_t)msgSize]; 2283 // Write the fields. 2284 WriteDictUInt32Field(outputStream, [aKey unsignedIntValue], kMapKeyFieldNumber, keyDataType); 2285 WriteDictInt64Field(outputStream, [aValue longLongValue], kMapValueFieldNumber, valueDataType); 2286 }]; 2287 } 2288 2289 - (void)setGPBGenericValue:(GPBGenericValue *)value 2290 forGPBGenericValueKey:(GPBGenericValue *)key { 2291 [_dictionary setObject:@(value->valueInt64) forKey:@(key->valueUInt32)]; 2292 } 2293 2294 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 2295 [self enumerateKeysAndValuesUsingBlock:^(uint32_t key, int64_t value, BOOL *stop) { 2296 #pragma unused(stop) 2297 block([NSString stringWithFormat:@"%u", key], [NSString stringWithFormat:@"%lld", value]); 2298 }]; 2299 } 2300 2301 - (BOOL)valueForKey:(uint32_t)key value:(int64_t *)value { 2302 NSNumber *wrapped = [_dictionary objectForKey:@(key)]; 2303 if (wrapped && value) { 2304 *value = [wrapped longLongValue]; 2305 } 2306 return (wrapped != NULL); 2307 } 2308 2309 - (void)addEntriesFromDictionary:(GPBUInt32Int64Dictionary *)otherDictionary { 2310 if (otherDictionary) { 2311 [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 2312 if (_autocreator) { 2313 GPBAutocreatedDictionaryModified(_autocreator, self); 2314 } 2315 } 2316 } 2317 2318 - (void)setValue:(int64_t)value forKey:(uint32_t)key { 2319 [_dictionary setObject:@(value) forKey:@(key)]; 2320 if (_autocreator) { 2321 GPBAutocreatedDictionaryModified(_autocreator, self); 2322 } 2323 } 2324 2325 - (void)removeValueForKey:(uint32_t)aKey { 2326 [_dictionary removeObjectForKey:@(aKey)]; 2327 } 2328 2329 - (void)removeAll { 2330 [_dictionary removeAllObjects]; 2331 } 2332 2333 @end 2334 2335 #pragma mark - UInt32 -> Bool 2336 2337 @implementation GPBUInt32BoolDictionary { 2338 @package 2339 NSMutableDictionary *_dictionary; 2340 } 2341 2342 + (instancetype)dictionary { 2343 return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; 2344 } 2345 2346 + (instancetype)dictionaryWithValue:(BOOL)value 2347 forKey:(uint32_t)key { 2348 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 2349 // on to get the type correct. 2350 return [[(GPBUInt32BoolDictionary*)[self alloc] initWithValues:&value 2351 forKeys:&key 2352 count:1] autorelease]; 2353 } 2354 2355 + (instancetype)dictionaryWithValues:(const BOOL [])values 2356 forKeys:(const uint32_t [])keys 2357 count:(NSUInteger)count { 2358 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 2359 // on to get the type correct. 2360 return [[(GPBUInt32BoolDictionary*)[self alloc] initWithValues:values 2361 forKeys:keys 2362 count:count] autorelease]; 2363 } 2364 2365 + (instancetype)dictionaryWithDictionary:(GPBUInt32BoolDictionary *)dictionary { 2366 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 2367 // on to get the type correct. 2368 return [[(GPBUInt32BoolDictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 2369 } 2370 2371 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 2372 return [[[self alloc] initWithCapacity:numItems] autorelease]; 2373 } 2374 2375 - (instancetype)init { 2376 return [self initWithValues:NULL forKeys:NULL count:0]; 2377 } 2378 2379 - (instancetype)initWithValues:(const BOOL [])values 2380 forKeys:(const uint32_t [])keys 2381 count:(NSUInteger)count { 2382 self = [super init]; 2383 if (self) { 2384 _dictionary = [[NSMutableDictionary alloc] init]; 2385 if (count && values && keys) { 2386 for (NSUInteger i = 0; i < count; ++i) { 2387 [_dictionary setObject:@(values[i]) forKey:@(keys[i])]; 2388 } 2389 } 2390 } 2391 return self; 2392 } 2393 2394 - (instancetype)initWithDictionary:(GPBUInt32BoolDictionary *)dictionary { 2395 self = [self initWithValues:NULL forKeys:NULL count:0]; 2396 if (self) { 2397 if (dictionary) { 2398 [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 2399 } 2400 } 2401 return self; 2402 } 2403 2404 - (instancetype)initWithCapacity:(NSUInteger)numItems { 2405 #pragma unused(numItems) 2406 return [self initWithValues:NULL forKeys:NULL count:0]; 2407 } 2408 2409 - (void)dealloc { 2410 NSAssert(!_autocreator, 2411 @"%@: Autocreator must be cleared before release, autocreator: %@", 2412 [self class], _autocreator); 2413 [_dictionary release]; 2414 [super dealloc]; 2415 } 2416 2417 - (instancetype)copyWithZone:(NSZone *)zone { 2418 return [[GPBUInt32BoolDictionary allocWithZone:zone] initWithDictionary:self]; 2419 } 2420 2421 - (BOOL)isEqual:(GPBUInt32BoolDictionary *)other { 2422 if (self == other) { 2423 return YES; 2424 } 2425 if (![other isKindOfClass:[GPBUInt32BoolDictionary class]]) { 2426 return NO; 2427 } 2428 return [_dictionary isEqual:other->_dictionary]; 2429 } 2430 2431 - (NSUInteger)hash { 2432 return _dictionary.count; 2433 } 2434 2435 - (NSString *)description { 2436 return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 2437 } 2438 2439 - (NSUInteger)count { 2440 return _dictionary.count; 2441 } 2442 2443 - (void)enumerateKeysAndValuesUsingBlock: 2444 (void (^)(uint32_t key, BOOL value, BOOL *stop))block { 2445 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 2446 NSNumber *aValue, 2447 BOOL *stop) { 2448 block([aKey unsignedIntValue], [aValue boolValue], stop); 2449 }]; 2450 } 2451 2452 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 2453 NSUInteger count = _dictionary.count; 2454 if (count == 0) { 2455 return 0; 2456 } 2457 2458 GPBDataType valueDataType = GPBGetFieldDataType(field); 2459 GPBDataType keyDataType = field.mapKeyDataType; 2460 __block size_t result = 0; 2461 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 2462 NSNumber *aValue, 2463 BOOL *stop) { 2464 #pragma unused(stop) 2465 size_t msgSize = ComputeDictUInt32FieldSize([aKey unsignedIntValue], kMapKeyFieldNumber, keyDataType); 2466 msgSize += ComputeDictBoolFieldSize([aValue boolValue], kMapValueFieldNumber, valueDataType); 2467 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 2468 }]; 2469 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 2470 result += tagSize * count; 2471 return result; 2472 } 2473 2474 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 2475 asField:(GPBFieldDescriptor *)field { 2476 GPBDataType valueDataType = GPBGetFieldDataType(field); 2477 GPBDataType keyDataType = field.mapKeyDataType; 2478 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 2479 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 2480 NSNumber *aValue, 2481 BOOL *stop) { 2482 #pragma unused(stop) 2483 // Write the tag. 2484 [outputStream writeInt32NoTag:tag]; 2485 // Write the size of the message. 2486 size_t msgSize = ComputeDictUInt32FieldSize([aKey unsignedIntValue], kMapKeyFieldNumber, keyDataType); 2487 msgSize += ComputeDictBoolFieldSize([aValue boolValue], kMapValueFieldNumber, valueDataType); 2488 [outputStream writeInt32NoTag:(int32_t)msgSize]; 2489 // Write the fields. 2490 WriteDictUInt32Field(outputStream, [aKey unsignedIntValue], kMapKeyFieldNumber, keyDataType); 2491 WriteDictBoolField(outputStream, [aValue boolValue], kMapValueFieldNumber, valueDataType); 2492 }]; 2493 } 2494 2495 - (void)setGPBGenericValue:(GPBGenericValue *)value 2496 forGPBGenericValueKey:(GPBGenericValue *)key { 2497 [_dictionary setObject:@(value->valueBool) forKey:@(key->valueUInt32)]; 2498 } 2499 2500 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 2501 [self enumerateKeysAndValuesUsingBlock:^(uint32_t key, BOOL value, BOOL *stop) { 2502 #pragma unused(stop) 2503 block([NSString stringWithFormat:@"%u", key], (value ? @"true" : @"false")); 2504 }]; 2505 } 2506 2507 - (BOOL)valueForKey:(uint32_t)key value:(BOOL *)value { 2508 NSNumber *wrapped = [_dictionary objectForKey:@(key)]; 2509 if (wrapped && value) { 2510 *value = [wrapped boolValue]; 2511 } 2512 return (wrapped != NULL); 2513 } 2514 2515 - (void)addEntriesFromDictionary:(GPBUInt32BoolDictionary *)otherDictionary { 2516 if (otherDictionary) { 2517 [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 2518 if (_autocreator) { 2519 GPBAutocreatedDictionaryModified(_autocreator, self); 2520 } 2521 } 2522 } 2523 2524 - (void)setValue:(BOOL)value forKey:(uint32_t)key { 2525 [_dictionary setObject:@(value) forKey:@(key)]; 2526 if (_autocreator) { 2527 GPBAutocreatedDictionaryModified(_autocreator, self); 2528 } 2529 } 2530 2531 - (void)removeValueForKey:(uint32_t)aKey { 2532 [_dictionary removeObjectForKey:@(aKey)]; 2533 } 2534 2535 - (void)removeAll { 2536 [_dictionary removeAllObjects]; 2537 } 2538 2539 @end 2540 2541 #pragma mark - UInt32 -> Float 2542 2543 @implementation GPBUInt32FloatDictionary { 2544 @package 2545 NSMutableDictionary *_dictionary; 2546 } 2547 2548 + (instancetype)dictionary { 2549 return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; 2550 } 2551 2552 + (instancetype)dictionaryWithValue:(float)value 2553 forKey:(uint32_t)key { 2554 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 2555 // on to get the type correct. 2556 return [[(GPBUInt32FloatDictionary*)[self alloc] initWithValues:&value 2557 forKeys:&key 2558 count:1] autorelease]; 2559 } 2560 2561 + (instancetype)dictionaryWithValues:(const float [])values 2562 forKeys:(const uint32_t [])keys 2563 count:(NSUInteger)count { 2564 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 2565 // on to get the type correct. 2566 return [[(GPBUInt32FloatDictionary*)[self alloc] initWithValues:values 2567 forKeys:keys 2568 count:count] autorelease]; 2569 } 2570 2571 + (instancetype)dictionaryWithDictionary:(GPBUInt32FloatDictionary *)dictionary { 2572 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 2573 // on to get the type correct. 2574 return [[(GPBUInt32FloatDictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 2575 } 2576 2577 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 2578 return [[[self alloc] initWithCapacity:numItems] autorelease]; 2579 } 2580 2581 - (instancetype)init { 2582 return [self initWithValues:NULL forKeys:NULL count:0]; 2583 } 2584 2585 - (instancetype)initWithValues:(const float [])values 2586 forKeys:(const uint32_t [])keys 2587 count:(NSUInteger)count { 2588 self = [super init]; 2589 if (self) { 2590 _dictionary = [[NSMutableDictionary alloc] init]; 2591 if (count && values && keys) { 2592 for (NSUInteger i = 0; i < count; ++i) { 2593 [_dictionary setObject:@(values[i]) forKey:@(keys[i])]; 2594 } 2595 } 2596 } 2597 return self; 2598 } 2599 2600 - (instancetype)initWithDictionary:(GPBUInt32FloatDictionary *)dictionary { 2601 self = [self initWithValues:NULL forKeys:NULL count:0]; 2602 if (self) { 2603 if (dictionary) { 2604 [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 2605 } 2606 } 2607 return self; 2608 } 2609 2610 - (instancetype)initWithCapacity:(NSUInteger)numItems { 2611 #pragma unused(numItems) 2612 return [self initWithValues:NULL forKeys:NULL count:0]; 2613 } 2614 2615 - (void)dealloc { 2616 NSAssert(!_autocreator, 2617 @"%@: Autocreator must be cleared before release, autocreator: %@", 2618 [self class], _autocreator); 2619 [_dictionary release]; 2620 [super dealloc]; 2621 } 2622 2623 - (instancetype)copyWithZone:(NSZone *)zone { 2624 return [[GPBUInt32FloatDictionary allocWithZone:zone] initWithDictionary:self]; 2625 } 2626 2627 - (BOOL)isEqual:(GPBUInt32FloatDictionary *)other { 2628 if (self == other) { 2629 return YES; 2630 } 2631 if (![other isKindOfClass:[GPBUInt32FloatDictionary class]]) { 2632 return NO; 2633 } 2634 return [_dictionary isEqual:other->_dictionary]; 2635 } 2636 2637 - (NSUInteger)hash { 2638 return _dictionary.count; 2639 } 2640 2641 - (NSString *)description { 2642 return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 2643 } 2644 2645 - (NSUInteger)count { 2646 return _dictionary.count; 2647 } 2648 2649 - (void)enumerateKeysAndValuesUsingBlock: 2650 (void (^)(uint32_t key, float value, BOOL *stop))block { 2651 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 2652 NSNumber *aValue, 2653 BOOL *stop) { 2654 block([aKey unsignedIntValue], [aValue floatValue], stop); 2655 }]; 2656 } 2657 2658 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 2659 NSUInteger count = _dictionary.count; 2660 if (count == 0) { 2661 return 0; 2662 } 2663 2664 GPBDataType valueDataType = GPBGetFieldDataType(field); 2665 GPBDataType keyDataType = field.mapKeyDataType; 2666 __block size_t result = 0; 2667 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 2668 NSNumber *aValue, 2669 BOOL *stop) { 2670 #pragma unused(stop) 2671 size_t msgSize = ComputeDictUInt32FieldSize([aKey unsignedIntValue], kMapKeyFieldNumber, keyDataType); 2672 msgSize += ComputeDictFloatFieldSize([aValue floatValue], kMapValueFieldNumber, valueDataType); 2673 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 2674 }]; 2675 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 2676 result += tagSize * count; 2677 return result; 2678 } 2679 2680 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 2681 asField:(GPBFieldDescriptor *)field { 2682 GPBDataType valueDataType = GPBGetFieldDataType(field); 2683 GPBDataType keyDataType = field.mapKeyDataType; 2684 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 2685 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 2686 NSNumber *aValue, 2687 BOOL *stop) { 2688 #pragma unused(stop) 2689 // Write the tag. 2690 [outputStream writeInt32NoTag:tag]; 2691 // Write the size of the message. 2692 size_t msgSize = ComputeDictUInt32FieldSize([aKey unsignedIntValue], kMapKeyFieldNumber, keyDataType); 2693 msgSize += ComputeDictFloatFieldSize([aValue floatValue], kMapValueFieldNumber, valueDataType); 2694 [outputStream writeInt32NoTag:(int32_t)msgSize]; 2695 // Write the fields. 2696 WriteDictUInt32Field(outputStream, [aKey unsignedIntValue], kMapKeyFieldNumber, keyDataType); 2697 WriteDictFloatField(outputStream, [aValue floatValue], kMapValueFieldNumber, valueDataType); 2698 }]; 2699 } 2700 2701 - (void)setGPBGenericValue:(GPBGenericValue *)value 2702 forGPBGenericValueKey:(GPBGenericValue *)key { 2703 [_dictionary setObject:@(value->valueFloat) forKey:@(key->valueUInt32)]; 2704 } 2705 2706 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 2707 [self enumerateKeysAndValuesUsingBlock:^(uint32_t key, float value, BOOL *stop) { 2708 #pragma unused(stop) 2709 block([NSString stringWithFormat:@"%u", key], [NSString stringWithFormat:@"%.*g", FLT_DIG, value]); 2710 }]; 2711 } 2712 2713 - (BOOL)valueForKey:(uint32_t)key value:(float *)value { 2714 NSNumber *wrapped = [_dictionary objectForKey:@(key)]; 2715 if (wrapped && value) { 2716 *value = [wrapped floatValue]; 2717 } 2718 return (wrapped != NULL); 2719 } 2720 2721 - (void)addEntriesFromDictionary:(GPBUInt32FloatDictionary *)otherDictionary { 2722 if (otherDictionary) { 2723 [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 2724 if (_autocreator) { 2725 GPBAutocreatedDictionaryModified(_autocreator, self); 2726 } 2727 } 2728 } 2729 2730 - (void)setValue:(float)value forKey:(uint32_t)key { 2731 [_dictionary setObject:@(value) forKey:@(key)]; 2732 if (_autocreator) { 2733 GPBAutocreatedDictionaryModified(_autocreator, self); 2734 } 2735 } 2736 2737 - (void)removeValueForKey:(uint32_t)aKey { 2738 [_dictionary removeObjectForKey:@(aKey)]; 2739 } 2740 2741 - (void)removeAll { 2742 [_dictionary removeAllObjects]; 2743 } 2744 2745 @end 2746 2747 #pragma mark - UInt32 -> Double 2748 2749 @implementation GPBUInt32DoubleDictionary { 2750 @package 2751 NSMutableDictionary *_dictionary; 2752 } 2753 2754 + (instancetype)dictionary { 2755 return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; 2756 } 2757 2758 + (instancetype)dictionaryWithValue:(double)value 2759 forKey:(uint32_t)key { 2760 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 2761 // on to get the type correct. 2762 return [[(GPBUInt32DoubleDictionary*)[self alloc] initWithValues:&value 2763 forKeys:&key 2764 count:1] autorelease]; 2765 } 2766 2767 + (instancetype)dictionaryWithValues:(const double [])values 2768 forKeys:(const uint32_t [])keys 2769 count:(NSUInteger)count { 2770 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 2771 // on to get the type correct. 2772 return [[(GPBUInt32DoubleDictionary*)[self alloc] initWithValues:values 2773 forKeys:keys 2774 count:count] autorelease]; 2775 } 2776 2777 + (instancetype)dictionaryWithDictionary:(GPBUInt32DoubleDictionary *)dictionary { 2778 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 2779 // on to get the type correct. 2780 return [[(GPBUInt32DoubleDictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 2781 } 2782 2783 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 2784 return [[[self alloc] initWithCapacity:numItems] autorelease]; 2785 } 2786 2787 - (instancetype)init { 2788 return [self initWithValues:NULL forKeys:NULL count:0]; 2789 } 2790 2791 - (instancetype)initWithValues:(const double [])values 2792 forKeys:(const uint32_t [])keys 2793 count:(NSUInteger)count { 2794 self = [super init]; 2795 if (self) { 2796 _dictionary = [[NSMutableDictionary alloc] init]; 2797 if (count && values && keys) { 2798 for (NSUInteger i = 0; i < count; ++i) { 2799 [_dictionary setObject:@(values[i]) forKey:@(keys[i])]; 2800 } 2801 } 2802 } 2803 return self; 2804 } 2805 2806 - (instancetype)initWithDictionary:(GPBUInt32DoubleDictionary *)dictionary { 2807 self = [self initWithValues:NULL forKeys:NULL count:0]; 2808 if (self) { 2809 if (dictionary) { 2810 [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 2811 } 2812 } 2813 return self; 2814 } 2815 2816 - (instancetype)initWithCapacity:(NSUInteger)numItems { 2817 #pragma unused(numItems) 2818 return [self initWithValues:NULL forKeys:NULL count:0]; 2819 } 2820 2821 - (void)dealloc { 2822 NSAssert(!_autocreator, 2823 @"%@: Autocreator must be cleared before release, autocreator: %@", 2824 [self class], _autocreator); 2825 [_dictionary release]; 2826 [super dealloc]; 2827 } 2828 2829 - (instancetype)copyWithZone:(NSZone *)zone { 2830 return [[GPBUInt32DoubleDictionary allocWithZone:zone] initWithDictionary:self]; 2831 } 2832 2833 - (BOOL)isEqual:(GPBUInt32DoubleDictionary *)other { 2834 if (self == other) { 2835 return YES; 2836 } 2837 if (![other isKindOfClass:[GPBUInt32DoubleDictionary class]]) { 2838 return NO; 2839 } 2840 return [_dictionary isEqual:other->_dictionary]; 2841 } 2842 2843 - (NSUInteger)hash { 2844 return _dictionary.count; 2845 } 2846 2847 - (NSString *)description { 2848 return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 2849 } 2850 2851 - (NSUInteger)count { 2852 return _dictionary.count; 2853 } 2854 2855 - (void)enumerateKeysAndValuesUsingBlock: 2856 (void (^)(uint32_t key, double value, BOOL *stop))block { 2857 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 2858 NSNumber *aValue, 2859 BOOL *stop) { 2860 block([aKey unsignedIntValue], [aValue doubleValue], stop); 2861 }]; 2862 } 2863 2864 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 2865 NSUInteger count = _dictionary.count; 2866 if (count == 0) { 2867 return 0; 2868 } 2869 2870 GPBDataType valueDataType = GPBGetFieldDataType(field); 2871 GPBDataType keyDataType = field.mapKeyDataType; 2872 __block size_t result = 0; 2873 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 2874 NSNumber *aValue, 2875 BOOL *stop) { 2876 #pragma unused(stop) 2877 size_t msgSize = ComputeDictUInt32FieldSize([aKey unsignedIntValue], kMapKeyFieldNumber, keyDataType); 2878 msgSize += ComputeDictDoubleFieldSize([aValue doubleValue], kMapValueFieldNumber, valueDataType); 2879 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 2880 }]; 2881 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 2882 result += tagSize * count; 2883 return result; 2884 } 2885 2886 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 2887 asField:(GPBFieldDescriptor *)field { 2888 GPBDataType valueDataType = GPBGetFieldDataType(field); 2889 GPBDataType keyDataType = field.mapKeyDataType; 2890 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 2891 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 2892 NSNumber *aValue, 2893 BOOL *stop) { 2894 #pragma unused(stop) 2895 // Write the tag. 2896 [outputStream writeInt32NoTag:tag]; 2897 // Write the size of the message. 2898 size_t msgSize = ComputeDictUInt32FieldSize([aKey unsignedIntValue], kMapKeyFieldNumber, keyDataType); 2899 msgSize += ComputeDictDoubleFieldSize([aValue doubleValue], kMapValueFieldNumber, valueDataType); 2900 [outputStream writeInt32NoTag:(int32_t)msgSize]; 2901 // Write the fields. 2902 WriteDictUInt32Field(outputStream, [aKey unsignedIntValue], kMapKeyFieldNumber, keyDataType); 2903 WriteDictDoubleField(outputStream, [aValue doubleValue], kMapValueFieldNumber, valueDataType); 2904 }]; 2905 } 2906 2907 - (void)setGPBGenericValue:(GPBGenericValue *)value 2908 forGPBGenericValueKey:(GPBGenericValue *)key { 2909 [_dictionary setObject:@(value->valueDouble) forKey:@(key->valueUInt32)]; 2910 } 2911 2912 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 2913 [self enumerateKeysAndValuesUsingBlock:^(uint32_t key, double value, BOOL *stop) { 2914 #pragma unused(stop) 2915 block([NSString stringWithFormat:@"%u", key], [NSString stringWithFormat:@"%.*lg", DBL_DIG, value]); 2916 }]; 2917 } 2918 2919 - (BOOL)valueForKey:(uint32_t)key value:(double *)value { 2920 NSNumber *wrapped = [_dictionary objectForKey:@(key)]; 2921 if (wrapped && value) { 2922 *value = [wrapped doubleValue]; 2923 } 2924 return (wrapped != NULL); 2925 } 2926 2927 - (void)addEntriesFromDictionary:(GPBUInt32DoubleDictionary *)otherDictionary { 2928 if (otherDictionary) { 2929 [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 2930 if (_autocreator) { 2931 GPBAutocreatedDictionaryModified(_autocreator, self); 2932 } 2933 } 2934 } 2935 2936 - (void)setValue:(double)value forKey:(uint32_t)key { 2937 [_dictionary setObject:@(value) forKey:@(key)]; 2938 if (_autocreator) { 2939 GPBAutocreatedDictionaryModified(_autocreator, self); 2940 } 2941 } 2942 2943 - (void)removeValueForKey:(uint32_t)aKey { 2944 [_dictionary removeObjectForKey:@(aKey)]; 2945 } 2946 2947 - (void)removeAll { 2948 [_dictionary removeAllObjects]; 2949 } 2950 2951 @end 2952 2953 #pragma mark - UInt32 -> Enum 2954 2955 @implementation GPBUInt32EnumDictionary { 2956 @package 2957 NSMutableDictionary *_dictionary; 2958 GPBEnumValidationFunc _validationFunc; 2959 } 2960 2961 @synthesize validationFunc = _validationFunc; 2962 2963 + (instancetype)dictionary { 2964 return [[[self alloc] initWithValidationFunction:NULL 2965 rawValues:NULL 2966 forKeys:NULL 2967 count:0] autorelease]; 2968 } 2969 2970 + (instancetype)dictionaryWithValidationFunction:(GPBEnumValidationFunc)func { 2971 return [[[self alloc] initWithValidationFunction:func 2972 rawValues:NULL 2973 forKeys:NULL 2974 count:0] autorelease]; 2975 } 2976 2977 + (instancetype)dictionaryWithValidationFunction:(GPBEnumValidationFunc)func 2978 rawValue:(int32_t)rawValue 2979 forKey:(uint32_t)key { 2980 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 2981 // on to get the type correct. 2982 return [[(GPBUInt32EnumDictionary*)[self alloc] initWithValidationFunction:func 2983 rawValues:&rawValue 2984 forKeys:&key 2985 count:1] autorelease]; 2986 } 2987 2988 + (instancetype)dictionaryWithValidationFunction:(GPBEnumValidationFunc)func 2989 rawValues:(const int32_t [])rawValues 2990 forKeys:(const uint32_t [])keys 2991 count:(NSUInteger)count { 2992 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 2993 // on to get the type correct. 2994 return [[(GPBUInt32EnumDictionary*)[self alloc] initWithValidationFunction:func 2995 rawValues:rawValues 2996 forKeys:keys 2997 count:count] autorelease]; 2998 } 2999 3000 + (instancetype)dictionaryWithDictionary:(GPBUInt32EnumDictionary *)dictionary { 3001 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 3002 // on to get the type correct. 3003 return [[(GPBUInt32EnumDictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 3004 } 3005 3006 + (instancetype)dictionaryWithValidationFunction:(GPBEnumValidationFunc)func 3007 capacity:(NSUInteger)numItems { 3008 return [[[self alloc] initWithValidationFunction:func capacity:numItems] autorelease]; 3009 } 3010 3011 - (instancetype)init { 3012 return [self initWithValidationFunction:NULL rawValues:NULL forKeys:NULL count:0]; 3013 } 3014 3015 - (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func { 3016 return [self initWithValidationFunction:func rawValues:NULL forKeys:NULL count:0]; 3017 } 3018 3019 - (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func 3020 rawValues:(const int32_t [])rawValues 3021 forKeys:(const uint32_t [])keys 3022 count:(NSUInteger)count { 3023 self = [super init]; 3024 if (self) { 3025 _dictionary = [[NSMutableDictionary alloc] init]; 3026 _validationFunc = (func != NULL ? func : DictDefault_IsValidValue); 3027 if (count && rawValues && keys) { 3028 for (NSUInteger i = 0; i < count; ++i) { 3029 [_dictionary setObject:@(rawValues[i]) forKey:@(keys[i])]; 3030 } 3031 } 3032 } 3033 return self; 3034 } 3035 3036 - (instancetype)initWithDictionary:(GPBUInt32EnumDictionary *)dictionary { 3037 self = [self initWithValidationFunction:dictionary.validationFunc 3038 rawValues:NULL 3039 forKeys:NULL 3040 count:0]; 3041 if (self) { 3042 if (dictionary) { 3043 [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 3044 } 3045 } 3046 return self; 3047 } 3048 3049 - (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func 3050 capacity:(NSUInteger)numItems { 3051 #pragma unused(numItems) 3052 return [self initWithValidationFunction:func rawValues:NULL forKeys:NULL count:0]; 3053 } 3054 3055 - (void)dealloc { 3056 NSAssert(!_autocreator, 3057 @"%@: Autocreator must be cleared before release, autocreator: %@", 3058 [self class], _autocreator); 3059 [_dictionary release]; 3060 [super dealloc]; 3061 } 3062 3063 - (instancetype)copyWithZone:(NSZone *)zone { 3064 return [[GPBUInt32EnumDictionary allocWithZone:zone] initWithDictionary:self]; 3065 } 3066 3067 - (BOOL)isEqual:(GPBUInt32EnumDictionary *)other { 3068 if (self == other) { 3069 return YES; 3070 } 3071 if (![other isKindOfClass:[GPBUInt32EnumDictionary class]]) { 3072 return NO; 3073 } 3074 return [_dictionary isEqual:other->_dictionary]; 3075 } 3076 3077 - (NSUInteger)hash { 3078 return _dictionary.count; 3079 } 3080 3081 - (NSString *)description { 3082 return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 3083 } 3084 3085 - (NSUInteger)count { 3086 return _dictionary.count; 3087 } 3088 3089 - (void)enumerateKeysAndRawValuesUsingBlock: 3090 (void (^)(uint32_t key, int32_t value, BOOL *stop))block { 3091 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 3092 NSNumber *aValue, 3093 BOOL *stop) { 3094 block([aKey unsignedIntValue], [aValue intValue], stop); 3095 }]; 3096 } 3097 3098 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 3099 NSUInteger count = _dictionary.count; 3100 if (count == 0) { 3101 return 0; 3102 } 3103 3104 GPBDataType valueDataType = GPBGetFieldDataType(field); 3105 GPBDataType keyDataType = field.mapKeyDataType; 3106 __block size_t result = 0; 3107 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 3108 NSNumber *aValue, 3109 BOOL *stop) { 3110 #pragma unused(stop) 3111 size_t msgSize = ComputeDictUInt32FieldSize([aKey unsignedIntValue], kMapKeyFieldNumber, keyDataType); 3112 msgSize += ComputeDictEnumFieldSize([aValue intValue], kMapValueFieldNumber, valueDataType); 3113 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 3114 }]; 3115 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 3116 result += tagSize * count; 3117 return result; 3118 } 3119 3120 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 3121 asField:(GPBFieldDescriptor *)field { 3122 GPBDataType valueDataType = GPBGetFieldDataType(field); 3123 GPBDataType keyDataType = field.mapKeyDataType; 3124 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 3125 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 3126 NSNumber *aValue, 3127 BOOL *stop) { 3128 #pragma unused(stop) 3129 // Write the tag. 3130 [outputStream writeInt32NoTag:tag]; 3131 // Write the size of the message. 3132 size_t msgSize = ComputeDictUInt32FieldSize([aKey unsignedIntValue], kMapKeyFieldNumber, keyDataType); 3133 msgSize += ComputeDictEnumFieldSize([aValue intValue], kMapValueFieldNumber, valueDataType); 3134 [outputStream writeInt32NoTag:(int32_t)msgSize]; 3135 // Write the fields. 3136 WriteDictUInt32Field(outputStream, [aKey unsignedIntValue], kMapKeyFieldNumber, keyDataType); 3137 WriteDictEnumField(outputStream, [aValue intValue], kMapValueFieldNumber, valueDataType); 3138 }]; 3139 } 3140 3141 - (NSData *)serializedDataForUnknownValue:(int32_t)value 3142 forKey:(GPBGenericValue *)key 3143 keyDataType:(GPBDataType)keyDataType { 3144 size_t msgSize = ComputeDictUInt32FieldSize(key->valueUInt32, kMapKeyFieldNumber, keyDataType); 3145 msgSize += ComputeDictEnumFieldSize(value, kMapValueFieldNumber, GPBDataTypeEnum); 3146 NSMutableData *data = [NSMutableData dataWithLength:msgSize]; 3147 GPBCodedOutputStream *outputStream = [[GPBCodedOutputStream alloc] initWithData:data]; 3148 WriteDictUInt32Field(outputStream, key->valueUInt32, kMapKeyFieldNumber, keyDataType); 3149 WriteDictEnumField(outputStream, value, kMapValueFieldNumber, GPBDataTypeEnum); 3150 [outputStream release]; 3151 return data; 3152 } 3153 - (void)setGPBGenericValue:(GPBGenericValue *)value 3154 forGPBGenericValueKey:(GPBGenericValue *)key { 3155 [_dictionary setObject:@(value->valueEnum) forKey:@(key->valueUInt32)]; 3156 } 3157 3158 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 3159 [self enumerateKeysAndRawValuesUsingBlock:^(uint32_t key, int32_t value, BOOL *stop) { 3160 #pragma unused(stop) 3161 block([NSString stringWithFormat:@"%u", key], @(value)); 3162 }]; 3163 } 3164 3165 - (BOOL)valueForKey:(uint32_t)key value:(int32_t *)value { 3166 NSNumber *wrapped = [_dictionary objectForKey:@(key)]; 3167 if (wrapped && value) { 3168 int32_t result = [wrapped intValue]; 3169 if (!_validationFunc(result)) { 3170 result = kGPBUnrecognizedEnumeratorValue; 3171 } 3172 *value = result; 3173 } 3174 return (wrapped != NULL); 3175 } 3176 3177 - (BOOL)valueForKey:(uint32_t)key rawValue:(int32_t *)rawValue { 3178 NSNumber *wrapped = [_dictionary objectForKey:@(key)]; 3179 if (wrapped && rawValue) { 3180 *rawValue = [wrapped intValue]; 3181 } 3182 return (wrapped != NULL); 3183 } 3184 3185 - (void)enumerateKeysAndValuesUsingBlock: 3186 (void (^)(uint32_t key, int32_t value, BOOL *stop))block { 3187 GPBEnumValidationFunc func = _validationFunc; 3188 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 3189 NSNumber *aValue, 3190 BOOL *stop) { 3191 int32_t unwrapped = [aValue intValue]; 3192 if (!func(unwrapped)) { 3193 unwrapped = kGPBUnrecognizedEnumeratorValue; 3194 } 3195 block([aKey unsignedIntValue], unwrapped, stop); 3196 }]; 3197 } 3198 3199 - (void)addRawEntriesFromDictionary:(GPBUInt32EnumDictionary *)otherDictionary { 3200 if (otherDictionary) { 3201 [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 3202 if (_autocreator) { 3203 GPBAutocreatedDictionaryModified(_autocreator, self); 3204 } 3205 } 3206 } 3207 3208 - (void)setRawValue:(int32_t)value forKey:(uint32_t)key { 3209 [_dictionary setObject:@(value) forKey:@(key)]; 3210 if (_autocreator) { 3211 GPBAutocreatedDictionaryModified(_autocreator, self); 3212 } 3213 } 3214 3215 - (void)removeValueForKey:(uint32_t)aKey { 3216 [_dictionary removeObjectForKey:@(aKey)]; 3217 } 3218 3219 - (void)removeAll { 3220 [_dictionary removeAllObjects]; 3221 } 3222 3223 - (void)setValue:(int32_t)value forKey:(uint32_t)key { 3224 if (!_validationFunc(value)) { 3225 [NSException raise:NSInvalidArgumentException 3226 format:@"GPBUInt32EnumDictionary: Attempt to set an unknown enum value (%d)", 3227 value]; 3228 } 3229 3230 [_dictionary setObject:@(value) forKey:@(key)]; 3231 if (_autocreator) { 3232 GPBAutocreatedDictionaryModified(_autocreator, self); 3233 } 3234 } 3235 3236 @end 3237 3238 #pragma mark - UInt32 -> Object 3239 3240 @implementation GPBUInt32ObjectDictionary { 3241 @package 3242 NSMutableDictionary *_dictionary; 3243 } 3244 3245 + (instancetype)dictionary { 3246 return [[[self alloc] initWithObjects:NULL forKeys:NULL count:0] autorelease]; 3247 } 3248 3249 + (instancetype)dictionaryWithObject:(id)object 3250 forKey:(uint32_t)key { 3251 // Cast is needed so the compiler knows what class we are invoking initWithObjects:forKeys:count: 3252 // on to get the type correct. 3253 return [[(GPBUInt32ObjectDictionary*)[self alloc] initWithObjects:&object 3254 forKeys:&key 3255 count:1] autorelease]; 3256 } 3257 3258 + (instancetype)dictionaryWithObjects:(const id [])objects 3259 forKeys:(const uint32_t [])keys 3260 count:(NSUInteger)count { 3261 // Cast is needed so the compiler knows what class we are invoking initWithObjects:forKeys:count: 3262 // on to get the type correct. 3263 return [[(GPBUInt32ObjectDictionary*)[self alloc] initWithObjects:objects 3264 forKeys:keys 3265 count:count] autorelease]; 3266 } 3267 3268 + (instancetype)dictionaryWithDictionary:(GPBUInt32ObjectDictionary *)dictionary { 3269 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 3270 // on to get the type correct. 3271 return [[(GPBUInt32ObjectDictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 3272 } 3273 3274 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 3275 return [[[self alloc] initWithCapacity:numItems] autorelease]; 3276 } 3277 3278 - (instancetype)init { 3279 return [self initWithObjects:NULL forKeys:NULL count:0]; 3280 } 3281 3282 - (instancetype)initWithObjects:(const id [])objects 3283 forKeys:(const uint32_t [])keys 3284 count:(NSUInteger)count { 3285 self = [super init]; 3286 if (self) { 3287 _dictionary = [[NSMutableDictionary alloc] init]; 3288 if (count && objects && keys) { 3289 for (NSUInteger i = 0; i < count; ++i) { 3290 if (!objects[i]) { 3291 [NSException raise:NSInvalidArgumentException 3292 format:@"Attempting to add nil object to a Dictionary"]; 3293 } 3294 [_dictionary setObject:objects[i] forKey:@(keys[i])]; 3295 } 3296 } 3297 } 3298 return self; 3299 } 3300 3301 - (instancetype)initWithDictionary:(GPBUInt32ObjectDictionary *)dictionary { 3302 self = [self initWithObjects:NULL forKeys:NULL count:0]; 3303 if (self) { 3304 if (dictionary) { 3305 [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 3306 } 3307 } 3308 return self; 3309 } 3310 3311 - (instancetype)initWithCapacity:(NSUInteger)numItems { 3312 #pragma unused(numItems) 3313 return [self initWithObjects:NULL forKeys:NULL count:0]; 3314 } 3315 3316 - (void)dealloc { 3317 NSAssert(!_autocreator, 3318 @"%@: Autocreator must be cleared before release, autocreator: %@", 3319 [self class], _autocreator); 3320 [_dictionary release]; 3321 [super dealloc]; 3322 } 3323 3324 - (instancetype)copyWithZone:(NSZone *)zone { 3325 return [[GPBUInt32ObjectDictionary allocWithZone:zone] initWithDictionary:self]; 3326 } 3327 3328 - (BOOL)isEqual:(GPBUInt32ObjectDictionary *)other { 3329 if (self == other) { 3330 return YES; 3331 } 3332 if (![other isKindOfClass:[GPBUInt32ObjectDictionary class]]) { 3333 return NO; 3334 } 3335 return [_dictionary isEqual:other->_dictionary]; 3336 } 3337 3338 - (NSUInteger)hash { 3339 return _dictionary.count; 3340 } 3341 3342 - (NSString *)description { 3343 return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 3344 } 3345 3346 - (NSUInteger)count { 3347 return _dictionary.count; 3348 } 3349 3350 - (void)enumerateKeysAndObjectsUsingBlock: 3351 (void (^)(uint32_t key, id object, BOOL *stop))block { 3352 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 3353 id aObject, 3354 BOOL *stop) { 3355 block([aKey unsignedIntValue], aObject, stop); 3356 }]; 3357 } 3358 3359 - (BOOL)isInitialized { 3360 for (GPBMessage *msg in [_dictionary objectEnumerator]) { 3361 if (!msg.initialized) { 3362 return NO; 3363 } 3364 } 3365 return YES; 3366 } 3367 3368 - (instancetype)deepCopyWithZone:(NSZone *)zone { 3369 GPBUInt32ObjectDictionary *newDict = 3370 [[GPBUInt32ObjectDictionary alloc] init]; 3371 [_dictionary enumerateKeysAndObjectsUsingBlock:^(id aKey, 3372 GPBMessage *msg, 3373 BOOL *stop) { 3374 #pragma unused(stop) 3375 GPBMessage *copiedMsg = [msg copyWithZone:zone]; 3376 [newDict->_dictionary setObject:copiedMsg forKey:aKey]; 3377 [copiedMsg release]; 3378 }]; 3379 return newDict; 3380 } 3381 3382 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 3383 NSUInteger count = _dictionary.count; 3384 if (count == 0) { 3385 return 0; 3386 } 3387 3388 GPBDataType valueDataType = GPBGetFieldDataType(field); 3389 GPBDataType keyDataType = field.mapKeyDataType; 3390 __block size_t result = 0; 3391 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 3392 id aObject, 3393 BOOL *stop) { 3394 #pragma unused(stop) 3395 size_t msgSize = ComputeDictUInt32FieldSize([aKey unsignedIntValue], kMapKeyFieldNumber, keyDataType); 3396 msgSize += ComputeDictObjectFieldSize(aObject, kMapValueFieldNumber, valueDataType); 3397 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 3398 }]; 3399 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 3400 result += tagSize * count; 3401 return result; 3402 } 3403 3404 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 3405 asField:(GPBFieldDescriptor *)field { 3406 GPBDataType valueDataType = GPBGetFieldDataType(field); 3407 GPBDataType keyDataType = field.mapKeyDataType; 3408 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 3409 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 3410 id aObject, 3411 BOOL *stop) { 3412 #pragma unused(stop) 3413 // Write the tag. 3414 [outputStream writeInt32NoTag:tag]; 3415 // Write the size of the message. 3416 size_t msgSize = ComputeDictUInt32FieldSize([aKey unsignedIntValue], kMapKeyFieldNumber, keyDataType); 3417 msgSize += ComputeDictObjectFieldSize(aObject, kMapValueFieldNumber, valueDataType); 3418 [outputStream writeInt32NoTag:(int32_t)msgSize]; 3419 // Write the fields. 3420 WriteDictUInt32Field(outputStream, [aKey unsignedIntValue], kMapKeyFieldNumber, keyDataType); 3421 WriteDictObjectField(outputStream, aObject, kMapValueFieldNumber, valueDataType); 3422 }]; 3423 } 3424 3425 - (void)setGPBGenericValue:(GPBGenericValue *)value 3426 forGPBGenericValueKey:(GPBGenericValue *)key { 3427 [_dictionary setObject:value->valueString forKey:@(key->valueUInt32)]; 3428 } 3429 3430 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 3431 [self enumerateKeysAndObjectsUsingBlock:^(uint32_t key, id object, BOOL *stop) { 3432 #pragma unused(stop) 3433 block([NSString stringWithFormat:@"%u", key], object); 3434 }]; 3435 } 3436 3437 - (id)objectForKey:(uint32_t)key { 3438 id result = [_dictionary objectForKey:@(key)]; 3439 return result; 3440 } 3441 3442 - (void)addEntriesFromDictionary:(GPBUInt32ObjectDictionary *)otherDictionary { 3443 if (otherDictionary) { 3444 [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 3445 if (_autocreator) { 3446 GPBAutocreatedDictionaryModified(_autocreator, self); 3447 } 3448 } 3449 } 3450 3451 - (void)setObject:(id)object forKey:(uint32_t)key { 3452 if (!object) { 3453 [NSException raise:NSInvalidArgumentException 3454 format:@"Attempting to add nil object to a Dictionary"]; 3455 } 3456 [_dictionary setObject:object forKey:@(key)]; 3457 if (_autocreator) { 3458 GPBAutocreatedDictionaryModified(_autocreator, self); 3459 } 3460 } 3461 3462 - (void)removeObjectForKey:(uint32_t)aKey { 3463 [_dictionary removeObjectForKey:@(aKey)]; 3464 } 3465 3466 - (void)removeAll { 3467 [_dictionary removeAllObjects]; 3468 } 3469 3470 @end 3471 3472 //%PDDM-EXPAND DICTIONARY_IMPL_FOR_POD_KEY(Int32, int32_t) 3473 // This block of code is generated, do not edit it directly. 3474 3475 #pragma mark - Int32 -> UInt32 3476 3477 @implementation GPBInt32UInt32Dictionary { 3478 @package 3479 NSMutableDictionary *_dictionary; 3480 } 3481 3482 + (instancetype)dictionary { 3483 return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; 3484 } 3485 3486 + (instancetype)dictionaryWithValue:(uint32_t)value 3487 forKey:(int32_t)key { 3488 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 3489 // on to get the type correct. 3490 return [[(GPBInt32UInt32Dictionary*)[self alloc] initWithValues:&value 3491 forKeys:&key 3492 count:1] autorelease]; 3493 } 3494 3495 + (instancetype)dictionaryWithValues:(const uint32_t [])values 3496 forKeys:(const int32_t [])keys 3497 count:(NSUInteger)count { 3498 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 3499 // on to get the type correct. 3500 return [[(GPBInt32UInt32Dictionary*)[self alloc] initWithValues:values 3501 forKeys:keys 3502 count:count] autorelease]; 3503 } 3504 3505 + (instancetype)dictionaryWithDictionary:(GPBInt32UInt32Dictionary *)dictionary { 3506 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 3507 // on to get the type correct. 3508 return [[(GPBInt32UInt32Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 3509 } 3510 3511 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 3512 return [[[self alloc] initWithCapacity:numItems] autorelease]; 3513 } 3514 3515 - (instancetype)init { 3516 return [self initWithValues:NULL forKeys:NULL count:0]; 3517 } 3518 3519 - (instancetype)initWithValues:(const uint32_t [])values 3520 forKeys:(const int32_t [])keys 3521 count:(NSUInteger)count { 3522 self = [super init]; 3523 if (self) { 3524 _dictionary = [[NSMutableDictionary alloc] init]; 3525 if (count && values && keys) { 3526 for (NSUInteger i = 0; i < count; ++i) { 3527 [_dictionary setObject:@(values[i]) forKey:@(keys[i])]; 3528 } 3529 } 3530 } 3531 return self; 3532 } 3533 3534 - (instancetype)initWithDictionary:(GPBInt32UInt32Dictionary *)dictionary { 3535 self = [self initWithValues:NULL forKeys:NULL count:0]; 3536 if (self) { 3537 if (dictionary) { 3538 [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 3539 } 3540 } 3541 return self; 3542 } 3543 3544 - (instancetype)initWithCapacity:(NSUInteger)numItems { 3545 #pragma unused(numItems) 3546 return [self initWithValues:NULL forKeys:NULL count:0]; 3547 } 3548 3549 - (void)dealloc { 3550 NSAssert(!_autocreator, 3551 @"%@: Autocreator must be cleared before release, autocreator: %@", 3552 [self class], _autocreator); 3553 [_dictionary release]; 3554 [super dealloc]; 3555 } 3556 3557 - (instancetype)copyWithZone:(NSZone *)zone { 3558 return [[GPBInt32UInt32Dictionary allocWithZone:zone] initWithDictionary:self]; 3559 } 3560 3561 - (BOOL)isEqual:(GPBInt32UInt32Dictionary *)other { 3562 if (self == other) { 3563 return YES; 3564 } 3565 if (![other isKindOfClass:[GPBInt32UInt32Dictionary class]]) { 3566 return NO; 3567 } 3568 return [_dictionary isEqual:other->_dictionary]; 3569 } 3570 3571 - (NSUInteger)hash { 3572 return _dictionary.count; 3573 } 3574 3575 - (NSString *)description { 3576 return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 3577 } 3578 3579 - (NSUInteger)count { 3580 return _dictionary.count; 3581 } 3582 3583 - (void)enumerateKeysAndValuesUsingBlock: 3584 (void (^)(int32_t key, uint32_t value, BOOL *stop))block { 3585 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 3586 NSNumber *aValue, 3587 BOOL *stop) { 3588 block([aKey intValue], [aValue unsignedIntValue], stop); 3589 }]; 3590 } 3591 3592 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 3593 NSUInteger count = _dictionary.count; 3594 if (count == 0) { 3595 return 0; 3596 } 3597 3598 GPBDataType valueDataType = GPBGetFieldDataType(field); 3599 GPBDataType keyDataType = field.mapKeyDataType; 3600 __block size_t result = 0; 3601 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 3602 NSNumber *aValue, 3603 BOOL *stop) { 3604 #pragma unused(stop) 3605 size_t msgSize = ComputeDictInt32FieldSize([aKey intValue], kMapKeyFieldNumber, keyDataType); 3606 msgSize += ComputeDictUInt32FieldSize([aValue unsignedIntValue], kMapValueFieldNumber, valueDataType); 3607 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 3608 }]; 3609 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 3610 result += tagSize * count; 3611 return result; 3612 } 3613 3614 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 3615 asField:(GPBFieldDescriptor *)field { 3616 GPBDataType valueDataType = GPBGetFieldDataType(field); 3617 GPBDataType keyDataType = field.mapKeyDataType; 3618 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 3619 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 3620 NSNumber *aValue, 3621 BOOL *stop) { 3622 #pragma unused(stop) 3623 // Write the tag. 3624 [outputStream writeInt32NoTag:tag]; 3625 // Write the size of the message. 3626 size_t msgSize = ComputeDictInt32FieldSize([aKey intValue], kMapKeyFieldNumber, keyDataType); 3627 msgSize += ComputeDictUInt32FieldSize([aValue unsignedIntValue], kMapValueFieldNumber, valueDataType); 3628 [outputStream writeInt32NoTag:(int32_t)msgSize]; 3629 // Write the fields. 3630 WriteDictInt32Field(outputStream, [aKey intValue], kMapKeyFieldNumber, keyDataType); 3631 WriteDictUInt32Field(outputStream, [aValue unsignedIntValue], kMapValueFieldNumber, valueDataType); 3632 }]; 3633 } 3634 3635 - (void)setGPBGenericValue:(GPBGenericValue *)value 3636 forGPBGenericValueKey:(GPBGenericValue *)key { 3637 [_dictionary setObject:@(value->valueUInt32) forKey:@(key->valueInt32)]; 3638 } 3639 3640 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 3641 [self enumerateKeysAndValuesUsingBlock:^(int32_t key, uint32_t value, BOOL *stop) { 3642 #pragma unused(stop) 3643 block([NSString stringWithFormat:@"%d", key], [NSString stringWithFormat:@"%u", value]); 3644 }]; 3645 } 3646 3647 - (BOOL)valueForKey:(int32_t)key value:(uint32_t *)value { 3648 NSNumber *wrapped = [_dictionary objectForKey:@(key)]; 3649 if (wrapped && value) { 3650 *value = [wrapped unsignedIntValue]; 3651 } 3652 return (wrapped != NULL); 3653 } 3654 3655 - (void)addEntriesFromDictionary:(GPBInt32UInt32Dictionary *)otherDictionary { 3656 if (otherDictionary) { 3657 [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 3658 if (_autocreator) { 3659 GPBAutocreatedDictionaryModified(_autocreator, self); 3660 } 3661 } 3662 } 3663 3664 - (void)setValue:(uint32_t)value forKey:(int32_t)key { 3665 [_dictionary setObject:@(value) forKey:@(key)]; 3666 if (_autocreator) { 3667 GPBAutocreatedDictionaryModified(_autocreator, self); 3668 } 3669 } 3670 3671 - (void)removeValueForKey:(int32_t)aKey { 3672 [_dictionary removeObjectForKey:@(aKey)]; 3673 } 3674 3675 - (void)removeAll { 3676 [_dictionary removeAllObjects]; 3677 } 3678 3679 @end 3680 3681 #pragma mark - Int32 -> Int32 3682 3683 @implementation GPBInt32Int32Dictionary { 3684 @package 3685 NSMutableDictionary *_dictionary; 3686 } 3687 3688 + (instancetype)dictionary { 3689 return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; 3690 } 3691 3692 + (instancetype)dictionaryWithValue:(int32_t)value 3693 forKey:(int32_t)key { 3694 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 3695 // on to get the type correct. 3696 return [[(GPBInt32Int32Dictionary*)[self alloc] initWithValues:&value 3697 forKeys:&key 3698 count:1] autorelease]; 3699 } 3700 3701 + (instancetype)dictionaryWithValues:(const int32_t [])values 3702 forKeys:(const int32_t [])keys 3703 count:(NSUInteger)count { 3704 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 3705 // on to get the type correct. 3706 return [[(GPBInt32Int32Dictionary*)[self alloc] initWithValues:values 3707 forKeys:keys 3708 count:count] autorelease]; 3709 } 3710 3711 + (instancetype)dictionaryWithDictionary:(GPBInt32Int32Dictionary *)dictionary { 3712 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 3713 // on to get the type correct. 3714 return [[(GPBInt32Int32Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 3715 } 3716 3717 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 3718 return [[[self alloc] initWithCapacity:numItems] autorelease]; 3719 } 3720 3721 - (instancetype)init { 3722 return [self initWithValues:NULL forKeys:NULL count:0]; 3723 } 3724 3725 - (instancetype)initWithValues:(const int32_t [])values 3726 forKeys:(const int32_t [])keys 3727 count:(NSUInteger)count { 3728 self = [super init]; 3729 if (self) { 3730 _dictionary = [[NSMutableDictionary alloc] init]; 3731 if (count && values && keys) { 3732 for (NSUInteger i = 0; i < count; ++i) { 3733 [_dictionary setObject:@(values[i]) forKey:@(keys[i])]; 3734 } 3735 } 3736 } 3737 return self; 3738 } 3739 3740 - (instancetype)initWithDictionary:(GPBInt32Int32Dictionary *)dictionary { 3741 self = [self initWithValues:NULL forKeys:NULL count:0]; 3742 if (self) { 3743 if (dictionary) { 3744 [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 3745 } 3746 } 3747 return self; 3748 } 3749 3750 - (instancetype)initWithCapacity:(NSUInteger)numItems { 3751 #pragma unused(numItems) 3752 return [self initWithValues:NULL forKeys:NULL count:0]; 3753 } 3754 3755 - (void)dealloc { 3756 NSAssert(!_autocreator, 3757 @"%@: Autocreator must be cleared before release, autocreator: %@", 3758 [self class], _autocreator); 3759 [_dictionary release]; 3760 [super dealloc]; 3761 } 3762 3763 - (instancetype)copyWithZone:(NSZone *)zone { 3764 return [[GPBInt32Int32Dictionary allocWithZone:zone] initWithDictionary:self]; 3765 } 3766 3767 - (BOOL)isEqual:(GPBInt32Int32Dictionary *)other { 3768 if (self == other) { 3769 return YES; 3770 } 3771 if (![other isKindOfClass:[GPBInt32Int32Dictionary class]]) { 3772 return NO; 3773 } 3774 return [_dictionary isEqual:other->_dictionary]; 3775 } 3776 3777 - (NSUInteger)hash { 3778 return _dictionary.count; 3779 } 3780 3781 - (NSString *)description { 3782 return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 3783 } 3784 3785 - (NSUInteger)count { 3786 return _dictionary.count; 3787 } 3788 3789 - (void)enumerateKeysAndValuesUsingBlock: 3790 (void (^)(int32_t key, int32_t value, BOOL *stop))block { 3791 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 3792 NSNumber *aValue, 3793 BOOL *stop) { 3794 block([aKey intValue], [aValue intValue], stop); 3795 }]; 3796 } 3797 3798 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 3799 NSUInteger count = _dictionary.count; 3800 if (count == 0) { 3801 return 0; 3802 } 3803 3804 GPBDataType valueDataType = GPBGetFieldDataType(field); 3805 GPBDataType keyDataType = field.mapKeyDataType; 3806 __block size_t result = 0; 3807 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 3808 NSNumber *aValue, 3809 BOOL *stop) { 3810 #pragma unused(stop) 3811 size_t msgSize = ComputeDictInt32FieldSize([aKey intValue], kMapKeyFieldNumber, keyDataType); 3812 msgSize += ComputeDictInt32FieldSize([aValue intValue], kMapValueFieldNumber, valueDataType); 3813 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 3814 }]; 3815 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 3816 result += tagSize * count; 3817 return result; 3818 } 3819 3820 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 3821 asField:(GPBFieldDescriptor *)field { 3822 GPBDataType valueDataType = GPBGetFieldDataType(field); 3823 GPBDataType keyDataType = field.mapKeyDataType; 3824 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 3825 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 3826 NSNumber *aValue, 3827 BOOL *stop) { 3828 #pragma unused(stop) 3829 // Write the tag. 3830 [outputStream writeInt32NoTag:tag]; 3831 // Write the size of the message. 3832 size_t msgSize = ComputeDictInt32FieldSize([aKey intValue], kMapKeyFieldNumber, keyDataType); 3833 msgSize += ComputeDictInt32FieldSize([aValue intValue], kMapValueFieldNumber, valueDataType); 3834 [outputStream writeInt32NoTag:(int32_t)msgSize]; 3835 // Write the fields. 3836 WriteDictInt32Field(outputStream, [aKey intValue], kMapKeyFieldNumber, keyDataType); 3837 WriteDictInt32Field(outputStream, [aValue intValue], kMapValueFieldNumber, valueDataType); 3838 }]; 3839 } 3840 3841 - (void)setGPBGenericValue:(GPBGenericValue *)value 3842 forGPBGenericValueKey:(GPBGenericValue *)key { 3843 [_dictionary setObject:@(value->valueInt32) forKey:@(key->valueInt32)]; 3844 } 3845 3846 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 3847 [self enumerateKeysAndValuesUsingBlock:^(int32_t key, int32_t value, BOOL *stop) { 3848 #pragma unused(stop) 3849 block([NSString stringWithFormat:@"%d", key], [NSString stringWithFormat:@"%d", value]); 3850 }]; 3851 } 3852 3853 - (BOOL)valueForKey:(int32_t)key value:(int32_t *)value { 3854 NSNumber *wrapped = [_dictionary objectForKey:@(key)]; 3855 if (wrapped && value) { 3856 *value = [wrapped intValue]; 3857 } 3858 return (wrapped != NULL); 3859 } 3860 3861 - (void)addEntriesFromDictionary:(GPBInt32Int32Dictionary *)otherDictionary { 3862 if (otherDictionary) { 3863 [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 3864 if (_autocreator) { 3865 GPBAutocreatedDictionaryModified(_autocreator, self); 3866 } 3867 } 3868 } 3869 3870 - (void)setValue:(int32_t)value forKey:(int32_t)key { 3871 [_dictionary setObject:@(value) forKey:@(key)]; 3872 if (_autocreator) { 3873 GPBAutocreatedDictionaryModified(_autocreator, self); 3874 } 3875 } 3876 3877 - (void)removeValueForKey:(int32_t)aKey { 3878 [_dictionary removeObjectForKey:@(aKey)]; 3879 } 3880 3881 - (void)removeAll { 3882 [_dictionary removeAllObjects]; 3883 } 3884 3885 @end 3886 3887 #pragma mark - Int32 -> UInt64 3888 3889 @implementation GPBInt32UInt64Dictionary { 3890 @package 3891 NSMutableDictionary *_dictionary; 3892 } 3893 3894 + (instancetype)dictionary { 3895 return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; 3896 } 3897 3898 + (instancetype)dictionaryWithValue:(uint64_t)value 3899 forKey:(int32_t)key { 3900 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 3901 // on to get the type correct. 3902 return [[(GPBInt32UInt64Dictionary*)[self alloc] initWithValues:&value 3903 forKeys:&key 3904 count:1] autorelease]; 3905 } 3906 3907 + (instancetype)dictionaryWithValues:(const uint64_t [])values 3908 forKeys:(const int32_t [])keys 3909 count:(NSUInteger)count { 3910 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 3911 // on to get the type correct. 3912 return [[(GPBInt32UInt64Dictionary*)[self alloc] initWithValues:values 3913 forKeys:keys 3914 count:count] autorelease]; 3915 } 3916 3917 + (instancetype)dictionaryWithDictionary:(GPBInt32UInt64Dictionary *)dictionary { 3918 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 3919 // on to get the type correct. 3920 return [[(GPBInt32UInt64Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 3921 } 3922 3923 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 3924 return [[[self alloc] initWithCapacity:numItems] autorelease]; 3925 } 3926 3927 - (instancetype)init { 3928 return [self initWithValues:NULL forKeys:NULL count:0]; 3929 } 3930 3931 - (instancetype)initWithValues:(const uint64_t [])values 3932 forKeys:(const int32_t [])keys 3933 count:(NSUInteger)count { 3934 self = [super init]; 3935 if (self) { 3936 _dictionary = [[NSMutableDictionary alloc] init]; 3937 if (count && values && keys) { 3938 for (NSUInteger i = 0; i < count; ++i) { 3939 [_dictionary setObject:@(values[i]) forKey:@(keys[i])]; 3940 } 3941 } 3942 } 3943 return self; 3944 } 3945 3946 - (instancetype)initWithDictionary:(GPBInt32UInt64Dictionary *)dictionary { 3947 self = [self initWithValues:NULL forKeys:NULL count:0]; 3948 if (self) { 3949 if (dictionary) { 3950 [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 3951 } 3952 } 3953 return self; 3954 } 3955 3956 - (instancetype)initWithCapacity:(NSUInteger)numItems { 3957 #pragma unused(numItems) 3958 return [self initWithValues:NULL forKeys:NULL count:0]; 3959 } 3960 3961 - (void)dealloc { 3962 NSAssert(!_autocreator, 3963 @"%@: Autocreator must be cleared before release, autocreator: %@", 3964 [self class], _autocreator); 3965 [_dictionary release]; 3966 [super dealloc]; 3967 } 3968 3969 - (instancetype)copyWithZone:(NSZone *)zone { 3970 return [[GPBInt32UInt64Dictionary allocWithZone:zone] initWithDictionary:self]; 3971 } 3972 3973 - (BOOL)isEqual:(GPBInt32UInt64Dictionary *)other { 3974 if (self == other) { 3975 return YES; 3976 } 3977 if (![other isKindOfClass:[GPBInt32UInt64Dictionary class]]) { 3978 return NO; 3979 } 3980 return [_dictionary isEqual:other->_dictionary]; 3981 } 3982 3983 - (NSUInteger)hash { 3984 return _dictionary.count; 3985 } 3986 3987 - (NSString *)description { 3988 return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 3989 } 3990 3991 - (NSUInteger)count { 3992 return _dictionary.count; 3993 } 3994 3995 - (void)enumerateKeysAndValuesUsingBlock: 3996 (void (^)(int32_t key, uint64_t value, BOOL *stop))block { 3997 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 3998 NSNumber *aValue, 3999 BOOL *stop) { 4000 block([aKey intValue], [aValue unsignedLongLongValue], stop); 4001 }]; 4002 } 4003 4004 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 4005 NSUInteger count = _dictionary.count; 4006 if (count == 0) { 4007 return 0; 4008 } 4009 4010 GPBDataType valueDataType = GPBGetFieldDataType(field); 4011 GPBDataType keyDataType = field.mapKeyDataType; 4012 __block size_t result = 0; 4013 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 4014 NSNumber *aValue, 4015 BOOL *stop) { 4016 #pragma unused(stop) 4017 size_t msgSize = ComputeDictInt32FieldSize([aKey intValue], kMapKeyFieldNumber, keyDataType); 4018 msgSize += ComputeDictUInt64FieldSize([aValue unsignedLongLongValue], kMapValueFieldNumber, valueDataType); 4019 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 4020 }]; 4021 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 4022 result += tagSize * count; 4023 return result; 4024 } 4025 4026 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 4027 asField:(GPBFieldDescriptor *)field { 4028 GPBDataType valueDataType = GPBGetFieldDataType(field); 4029 GPBDataType keyDataType = field.mapKeyDataType; 4030 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 4031 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 4032 NSNumber *aValue, 4033 BOOL *stop) { 4034 #pragma unused(stop) 4035 // Write the tag. 4036 [outputStream writeInt32NoTag:tag]; 4037 // Write the size of the message. 4038 size_t msgSize = ComputeDictInt32FieldSize([aKey intValue], kMapKeyFieldNumber, keyDataType); 4039 msgSize += ComputeDictUInt64FieldSize([aValue unsignedLongLongValue], kMapValueFieldNumber, valueDataType); 4040 [outputStream writeInt32NoTag:(int32_t)msgSize]; 4041 // Write the fields. 4042 WriteDictInt32Field(outputStream, [aKey intValue], kMapKeyFieldNumber, keyDataType); 4043 WriteDictUInt64Field(outputStream, [aValue unsignedLongLongValue], kMapValueFieldNumber, valueDataType); 4044 }]; 4045 } 4046 4047 - (void)setGPBGenericValue:(GPBGenericValue *)value 4048 forGPBGenericValueKey:(GPBGenericValue *)key { 4049 [_dictionary setObject:@(value->valueUInt64) forKey:@(key->valueInt32)]; 4050 } 4051 4052 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 4053 [self enumerateKeysAndValuesUsingBlock:^(int32_t key, uint64_t value, BOOL *stop) { 4054 #pragma unused(stop) 4055 block([NSString stringWithFormat:@"%d", key], [NSString stringWithFormat:@"%llu", value]); 4056 }]; 4057 } 4058 4059 - (BOOL)valueForKey:(int32_t)key value:(uint64_t *)value { 4060 NSNumber *wrapped = [_dictionary objectForKey:@(key)]; 4061 if (wrapped && value) { 4062 *value = [wrapped unsignedLongLongValue]; 4063 } 4064 return (wrapped != NULL); 4065 } 4066 4067 - (void)addEntriesFromDictionary:(GPBInt32UInt64Dictionary *)otherDictionary { 4068 if (otherDictionary) { 4069 [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 4070 if (_autocreator) { 4071 GPBAutocreatedDictionaryModified(_autocreator, self); 4072 } 4073 } 4074 } 4075 4076 - (void)setValue:(uint64_t)value forKey:(int32_t)key { 4077 [_dictionary setObject:@(value) forKey:@(key)]; 4078 if (_autocreator) { 4079 GPBAutocreatedDictionaryModified(_autocreator, self); 4080 } 4081 } 4082 4083 - (void)removeValueForKey:(int32_t)aKey { 4084 [_dictionary removeObjectForKey:@(aKey)]; 4085 } 4086 4087 - (void)removeAll { 4088 [_dictionary removeAllObjects]; 4089 } 4090 4091 @end 4092 4093 #pragma mark - Int32 -> Int64 4094 4095 @implementation GPBInt32Int64Dictionary { 4096 @package 4097 NSMutableDictionary *_dictionary; 4098 } 4099 4100 + (instancetype)dictionary { 4101 return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; 4102 } 4103 4104 + (instancetype)dictionaryWithValue:(int64_t)value 4105 forKey:(int32_t)key { 4106 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 4107 // on to get the type correct. 4108 return [[(GPBInt32Int64Dictionary*)[self alloc] initWithValues:&value 4109 forKeys:&key 4110 count:1] autorelease]; 4111 } 4112 4113 + (instancetype)dictionaryWithValues:(const int64_t [])values 4114 forKeys:(const int32_t [])keys 4115 count:(NSUInteger)count { 4116 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 4117 // on to get the type correct. 4118 return [[(GPBInt32Int64Dictionary*)[self alloc] initWithValues:values 4119 forKeys:keys 4120 count:count] autorelease]; 4121 } 4122 4123 + (instancetype)dictionaryWithDictionary:(GPBInt32Int64Dictionary *)dictionary { 4124 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 4125 // on to get the type correct. 4126 return [[(GPBInt32Int64Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 4127 } 4128 4129 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 4130 return [[[self alloc] initWithCapacity:numItems] autorelease]; 4131 } 4132 4133 - (instancetype)init { 4134 return [self initWithValues:NULL forKeys:NULL count:0]; 4135 } 4136 4137 - (instancetype)initWithValues:(const int64_t [])values 4138 forKeys:(const int32_t [])keys 4139 count:(NSUInteger)count { 4140 self = [super init]; 4141 if (self) { 4142 _dictionary = [[NSMutableDictionary alloc] init]; 4143 if (count && values && keys) { 4144 for (NSUInteger i = 0; i < count; ++i) { 4145 [_dictionary setObject:@(values[i]) forKey:@(keys[i])]; 4146 } 4147 } 4148 } 4149 return self; 4150 } 4151 4152 - (instancetype)initWithDictionary:(GPBInt32Int64Dictionary *)dictionary { 4153 self = [self initWithValues:NULL forKeys:NULL count:0]; 4154 if (self) { 4155 if (dictionary) { 4156 [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 4157 } 4158 } 4159 return self; 4160 } 4161 4162 - (instancetype)initWithCapacity:(NSUInteger)numItems { 4163 #pragma unused(numItems) 4164 return [self initWithValues:NULL forKeys:NULL count:0]; 4165 } 4166 4167 - (void)dealloc { 4168 NSAssert(!_autocreator, 4169 @"%@: Autocreator must be cleared before release, autocreator: %@", 4170 [self class], _autocreator); 4171 [_dictionary release]; 4172 [super dealloc]; 4173 } 4174 4175 - (instancetype)copyWithZone:(NSZone *)zone { 4176 return [[GPBInt32Int64Dictionary allocWithZone:zone] initWithDictionary:self]; 4177 } 4178 4179 - (BOOL)isEqual:(GPBInt32Int64Dictionary *)other { 4180 if (self == other) { 4181 return YES; 4182 } 4183 if (![other isKindOfClass:[GPBInt32Int64Dictionary class]]) { 4184 return NO; 4185 } 4186 return [_dictionary isEqual:other->_dictionary]; 4187 } 4188 4189 - (NSUInteger)hash { 4190 return _dictionary.count; 4191 } 4192 4193 - (NSString *)description { 4194 return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 4195 } 4196 4197 - (NSUInteger)count { 4198 return _dictionary.count; 4199 } 4200 4201 - (void)enumerateKeysAndValuesUsingBlock: 4202 (void (^)(int32_t key, int64_t value, BOOL *stop))block { 4203 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 4204 NSNumber *aValue, 4205 BOOL *stop) { 4206 block([aKey intValue], [aValue longLongValue], stop); 4207 }]; 4208 } 4209 4210 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 4211 NSUInteger count = _dictionary.count; 4212 if (count == 0) { 4213 return 0; 4214 } 4215 4216 GPBDataType valueDataType = GPBGetFieldDataType(field); 4217 GPBDataType keyDataType = field.mapKeyDataType; 4218 __block size_t result = 0; 4219 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 4220 NSNumber *aValue, 4221 BOOL *stop) { 4222 #pragma unused(stop) 4223 size_t msgSize = ComputeDictInt32FieldSize([aKey intValue], kMapKeyFieldNumber, keyDataType); 4224 msgSize += ComputeDictInt64FieldSize([aValue longLongValue], kMapValueFieldNumber, valueDataType); 4225 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 4226 }]; 4227 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 4228 result += tagSize * count; 4229 return result; 4230 } 4231 4232 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 4233 asField:(GPBFieldDescriptor *)field { 4234 GPBDataType valueDataType = GPBGetFieldDataType(field); 4235 GPBDataType keyDataType = field.mapKeyDataType; 4236 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 4237 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 4238 NSNumber *aValue, 4239 BOOL *stop) { 4240 #pragma unused(stop) 4241 // Write the tag. 4242 [outputStream writeInt32NoTag:tag]; 4243 // Write the size of the message. 4244 size_t msgSize = ComputeDictInt32FieldSize([aKey intValue], kMapKeyFieldNumber, keyDataType); 4245 msgSize += ComputeDictInt64FieldSize([aValue longLongValue], kMapValueFieldNumber, valueDataType); 4246 [outputStream writeInt32NoTag:(int32_t)msgSize]; 4247 // Write the fields. 4248 WriteDictInt32Field(outputStream, [aKey intValue], kMapKeyFieldNumber, keyDataType); 4249 WriteDictInt64Field(outputStream, [aValue longLongValue], kMapValueFieldNumber, valueDataType); 4250 }]; 4251 } 4252 4253 - (void)setGPBGenericValue:(GPBGenericValue *)value 4254 forGPBGenericValueKey:(GPBGenericValue *)key { 4255 [_dictionary setObject:@(value->valueInt64) forKey:@(key->valueInt32)]; 4256 } 4257 4258 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 4259 [self enumerateKeysAndValuesUsingBlock:^(int32_t key, int64_t value, BOOL *stop) { 4260 #pragma unused(stop) 4261 block([NSString stringWithFormat:@"%d", key], [NSString stringWithFormat:@"%lld", value]); 4262 }]; 4263 } 4264 4265 - (BOOL)valueForKey:(int32_t)key value:(int64_t *)value { 4266 NSNumber *wrapped = [_dictionary objectForKey:@(key)]; 4267 if (wrapped && value) { 4268 *value = [wrapped longLongValue]; 4269 } 4270 return (wrapped != NULL); 4271 } 4272 4273 - (void)addEntriesFromDictionary:(GPBInt32Int64Dictionary *)otherDictionary { 4274 if (otherDictionary) { 4275 [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 4276 if (_autocreator) { 4277 GPBAutocreatedDictionaryModified(_autocreator, self); 4278 } 4279 } 4280 } 4281 4282 - (void)setValue:(int64_t)value forKey:(int32_t)key { 4283 [_dictionary setObject:@(value) forKey:@(key)]; 4284 if (_autocreator) { 4285 GPBAutocreatedDictionaryModified(_autocreator, self); 4286 } 4287 } 4288 4289 - (void)removeValueForKey:(int32_t)aKey { 4290 [_dictionary removeObjectForKey:@(aKey)]; 4291 } 4292 4293 - (void)removeAll { 4294 [_dictionary removeAllObjects]; 4295 } 4296 4297 @end 4298 4299 #pragma mark - Int32 -> Bool 4300 4301 @implementation GPBInt32BoolDictionary { 4302 @package 4303 NSMutableDictionary *_dictionary; 4304 } 4305 4306 + (instancetype)dictionary { 4307 return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; 4308 } 4309 4310 + (instancetype)dictionaryWithValue:(BOOL)value 4311 forKey:(int32_t)key { 4312 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 4313 // on to get the type correct. 4314 return [[(GPBInt32BoolDictionary*)[self alloc] initWithValues:&value 4315 forKeys:&key 4316 count:1] autorelease]; 4317 } 4318 4319 + (instancetype)dictionaryWithValues:(const BOOL [])values 4320 forKeys:(const int32_t [])keys 4321 count:(NSUInteger)count { 4322 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 4323 // on to get the type correct. 4324 return [[(GPBInt32BoolDictionary*)[self alloc] initWithValues:values 4325 forKeys:keys 4326 count:count] autorelease]; 4327 } 4328 4329 + (instancetype)dictionaryWithDictionary:(GPBInt32BoolDictionary *)dictionary { 4330 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 4331 // on to get the type correct. 4332 return [[(GPBInt32BoolDictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 4333 } 4334 4335 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 4336 return [[[self alloc] initWithCapacity:numItems] autorelease]; 4337 } 4338 4339 - (instancetype)init { 4340 return [self initWithValues:NULL forKeys:NULL count:0]; 4341 } 4342 4343 - (instancetype)initWithValues:(const BOOL [])values 4344 forKeys:(const int32_t [])keys 4345 count:(NSUInteger)count { 4346 self = [super init]; 4347 if (self) { 4348 _dictionary = [[NSMutableDictionary alloc] init]; 4349 if (count && values && keys) { 4350 for (NSUInteger i = 0; i < count; ++i) { 4351 [_dictionary setObject:@(values[i]) forKey:@(keys[i])]; 4352 } 4353 } 4354 } 4355 return self; 4356 } 4357 4358 - (instancetype)initWithDictionary:(GPBInt32BoolDictionary *)dictionary { 4359 self = [self initWithValues:NULL forKeys:NULL count:0]; 4360 if (self) { 4361 if (dictionary) { 4362 [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 4363 } 4364 } 4365 return self; 4366 } 4367 4368 - (instancetype)initWithCapacity:(NSUInteger)numItems { 4369 #pragma unused(numItems) 4370 return [self initWithValues:NULL forKeys:NULL count:0]; 4371 } 4372 4373 - (void)dealloc { 4374 NSAssert(!_autocreator, 4375 @"%@: Autocreator must be cleared before release, autocreator: %@", 4376 [self class], _autocreator); 4377 [_dictionary release]; 4378 [super dealloc]; 4379 } 4380 4381 - (instancetype)copyWithZone:(NSZone *)zone { 4382 return [[GPBInt32BoolDictionary allocWithZone:zone] initWithDictionary:self]; 4383 } 4384 4385 - (BOOL)isEqual:(GPBInt32BoolDictionary *)other { 4386 if (self == other) { 4387 return YES; 4388 } 4389 if (![other isKindOfClass:[GPBInt32BoolDictionary class]]) { 4390 return NO; 4391 } 4392 return [_dictionary isEqual:other->_dictionary]; 4393 } 4394 4395 - (NSUInteger)hash { 4396 return _dictionary.count; 4397 } 4398 4399 - (NSString *)description { 4400 return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 4401 } 4402 4403 - (NSUInteger)count { 4404 return _dictionary.count; 4405 } 4406 4407 - (void)enumerateKeysAndValuesUsingBlock: 4408 (void (^)(int32_t key, BOOL value, BOOL *stop))block { 4409 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 4410 NSNumber *aValue, 4411 BOOL *stop) { 4412 block([aKey intValue], [aValue boolValue], stop); 4413 }]; 4414 } 4415 4416 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 4417 NSUInteger count = _dictionary.count; 4418 if (count == 0) { 4419 return 0; 4420 } 4421 4422 GPBDataType valueDataType = GPBGetFieldDataType(field); 4423 GPBDataType keyDataType = field.mapKeyDataType; 4424 __block size_t result = 0; 4425 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 4426 NSNumber *aValue, 4427 BOOL *stop) { 4428 #pragma unused(stop) 4429 size_t msgSize = ComputeDictInt32FieldSize([aKey intValue], kMapKeyFieldNumber, keyDataType); 4430 msgSize += ComputeDictBoolFieldSize([aValue boolValue], kMapValueFieldNumber, valueDataType); 4431 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 4432 }]; 4433 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 4434 result += tagSize * count; 4435 return result; 4436 } 4437 4438 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 4439 asField:(GPBFieldDescriptor *)field { 4440 GPBDataType valueDataType = GPBGetFieldDataType(field); 4441 GPBDataType keyDataType = field.mapKeyDataType; 4442 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 4443 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 4444 NSNumber *aValue, 4445 BOOL *stop) { 4446 #pragma unused(stop) 4447 // Write the tag. 4448 [outputStream writeInt32NoTag:tag]; 4449 // Write the size of the message. 4450 size_t msgSize = ComputeDictInt32FieldSize([aKey intValue], kMapKeyFieldNumber, keyDataType); 4451 msgSize += ComputeDictBoolFieldSize([aValue boolValue], kMapValueFieldNumber, valueDataType); 4452 [outputStream writeInt32NoTag:(int32_t)msgSize]; 4453 // Write the fields. 4454 WriteDictInt32Field(outputStream, [aKey intValue], kMapKeyFieldNumber, keyDataType); 4455 WriteDictBoolField(outputStream, [aValue boolValue], kMapValueFieldNumber, valueDataType); 4456 }]; 4457 } 4458 4459 - (void)setGPBGenericValue:(GPBGenericValue *)value 4460 forGPBGenericValueKey:(GPBGenericValue *)key { 4461 [_dictionary setObject:@(value->valueBool) forKey:@(key->valueInt32)]; 4462 } 4463 4464 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 4465 [self enumerateKeysAndValuesUsingBlock:^(int32_t key, BOOL value, BOOL *stop) { 4466 #pragma unused(stop) 4467 block([NSString stringWithFormat:@"%d", key], (value ? @"true" : @"false")); 4468 }]; 4469 } 4470 4471 - (BOOL)valueForKey:(int32_t)key value:(BOOL *)value { 4472 NSNumber *wrapped = [_dictionary objectForKey:@(key)]; 4473 if (wrapped && value) { 4474 *value = [wrapped boolValue]; 4475 } 4476 return (wrapped != NULL); 4477 } 4478 4479 - (void)addEntriesFromDictionary:(GPBInt32BoolDictionary *)otherDictionary { 4480 if (otherDictionary) { 4481 [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 4482 if (_autocreator) { 4483 GPBAutocreatedDictionaryModified(_autocreator, self); 4484 } 4485 } 4486 } 4487 4488 - (void)setValue:(BOOL)value forKey:(int32_t)key { 4489 [_dictionary setObject:@(value) forKey:@(key)]; 4490 if (_autocreator) { 4491 GPBAutocreatedDictionaryModified(_autocreator, self); 4492 } 4493 } 4494 4495 - (void)removeValueForKey:(int32_t)aKey { 4496 [_dictionary removeObjectForKey:@(aKey)]; 4497 } 4498 4499 - (void)removeAll { 4500 [_dictionary removeAllObjects]; 4501 } 4502 4503 @end 4504 4505 #pragma mark - Int32 -> Float 4506 4507 @implementation GPBInt32FloatDictionary { 4508 @package 4509 NSMutableDictionary *_dictionary; 4510 } 4511 4512 + (instancetype)dictionary { 4513 return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; 4514 } 4515 4516 + (instancetype)dictionaryWithValue:(float)value 4517 forKey:(int32_t)key { 4518 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 4519 // on to get the type correct. 4520 return [[(GPBInt32FloatDictionary*)[self alloc] initWithValues:&value 4521 forKeys:&key 4522 count:1] autorelease]; 4523 } 4524 4525 + (instancetype)dictionaryWithValues:(const float [])values 4526 forKeys:(const int32_t [])keys 4527 count:(NSUInteger)count { 4528 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 4529 // on to get the type correct. 4530 return [[(GPBInt32FloatDictionary*)[self alloc] initWithValues:values 4531 forKeys:keys 4532 count:count] autorelease]; 4533 } 4534 4535 + (instancetype)dictionaryWithDictionary:(GPBInt32FloatDictionary *)dictionary { 4536 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 4537 // on to get the type correct. 4538 return [[(GPBInt32FloatDictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 4539 } 4540 4541 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 4542 return [[[self alloc] initWithCapacity:numItems] autorelease]; 4543 } 4544 4545 - (instancetype)init { 4546 return [self initWithValues:NULL forKeys:NULL count:0]; 4547 } 4548 4549 - (instancetype)initWithValues:(const float [])values 4550 forKeys:(const int32_t [])keys 4551 count:(NSUInteger)count { 4552 self = [super init]; 4553 if (self) { 4554 _dictionary = [[NSMutableDictionary alloc] init]; 4555 if (count && values && keys) { 4556 for (NSUInteger i = 0; i < count; ++i) { 4557 [_dictionary setObject:@(values[i]) forKey:@(keys[i])]; 4558 } 4559 } 4560 } 4561 return self; 4562 } 4563 4564 - (instancetype)initWithDictionary:(GPBInt32FloatDictionary *)dictionary { 4565 self = [self initWithValues:NULL forKeys:NULL count:0]; 4566 if (self) { 4567 if (dictionary) { 4568 [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 4569 } 4570 } 4571 return self; 4572 } 4573 4574 - (instancetype)initWithCapacity:(NSUInteger)numItems { 4575 #pragma unused(numItems) 4576 return [self initWithValues:NULL forKeys:NULL count:0]; 4577 } 4578 4579 - (void)dealloc { 4580 NSAssert(!_autocreator, 4581 @"%@: Autocreator must be cleared before release, autocreator: %@", 4582 [self class], _autocreator); 4583 [_dictionary release]; 4584 [super dealloc]; 4585 } 4586 4587 - (instancetype)copyWithZone:(NSZone *)zone { 4588 return [[GPBInt32FloatDictionary allocWithZone:zone] initWithDictionary:self]; 4589 } 4590 4591 - (BOOL)isEqual:(GPBInt32FloatDictionary *)other { 4592 if (self == other) { 4593 return YES; 4594 } 4595 if (![other isKindOfClass:[GPBInt32FloatDictionary class]]) { 4596 return NO; 4597 } 4598 return [_dictionary isEqual:other->_dictionary]; 4599 } 4600 4601 - (NSUInteger)hash { 4602 return _dictionary.count; 4603 } 4604 4605 - (NSString *)description { 4606 return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 4607 } 4608 4609 - (NSUInteger)count { 4610 return _dictionary.count; 4611 } 4612 4613 - (void)enumerateKeysAndValuesUsingBlock: 4614 (void (^)(int32_t key, float value, BOOL *stop))block { 4615 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 4616 NSNumber *aValue, 4617 BOOL *stop) { 4618 block([aKey intValue], [aValue floatValue], stop); 4619 }]; 4620 } 4621 4622 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 4623 NSUInteger count = _dictionary.count; 4624 if (count == 0) { 4625 return 0; 4626 } 4627 4628 GPBDataType valueDataType = GPBGetFieldDataType(field); 4629 GPBDataType keyDataType = field.mapKeyDataType; 4630 __block size_t result = 0; 4631 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 4632 NSNumber *aValue, 4633 BOOL *stop) { 4634 #pragma unused(stop) 4635 size_t msgSize = ComputeDictInt32FieldSize([aKey intValue], kMapKeyFieldNumber, keyDataType); 4636 msgSize += ComputeDictFloatFieldSize([aValue floatValue], kMapValueFieldNumber, valueDataType); 4637 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 4638 }]; 4639 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 4640 result += tagSize * count; 4641 return result; 4642 } 4643 4644 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 4645 asField:(GPBFieldDescriptor *)field { 4646 GPBDataType valueDataType = GPBGetFieldDataType(field); 4647 GPBDataType keyDataType = field.mapKeyDataType; 4648 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 4649 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 4650 NSNumber *aValue, 4651 BOOL *stop) { 4652 #pragma unused(stop) 4653 // Write the tag. 4654 [outputStream writeInt32NoTag:tag]; 4655 // Write the size of the message. 4656 size_t msgSize = ComputeDictInt32FieldSize([aKey intValue], kMapKeyFieldNumber, keyDataType); 4657 msgSize += ComputeDictFloatFieldSize([aValue floatValue], kMapValueFieldNumber, valueDataType); 4658 [outputStream writeInt32NoTag:(int32_t)msgSize]; 4659 // Write the fields. 4660 WriteDictInt32Field(outputStream, [aKey intValue], kMapKeyFieldNumber, keyDataType); 4661 WriteDictFloatField(outputStream, [aValue floatValue], kMapValueFieldNumber, valueDataType); 4662 }]; 4663 } 4664 4665 - (void)setGPBGenericValue:(GPBGenericValue *)value 4666 forGPBGenericValueKey:(GPBGenericValue *)key { 4667 [_dictionary setObject:@(value->valueFloat) forKey:@(key->valueInt32)]; 4668 } 4669 4670 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 4671 [self enumerateKeysAndValuesUsingBlock:^(int32_t key, float value, BOOL *stop) { 4672 #pragma unused(stop) 4673 block([NSString stringWithFormat:@"%d", key], [NSString stringWithFormat:@"%.*g", FLT_DIG, value]); 4674 }]; 4675 } 4676 4677 - (BOOL)valueForKey:(int32_t)key value:(float *)value { 4678 NSNumber *wrapped = [_dictionary objectForKey:@(key)]; 4679 if (wrapped && value) { 4680 *value = [wrapped floatValue]; 4681 } 4682 return (wrapped != NULL); 4683 } 4684 4685 - (void)addEntriesFromDictionary:(GPBInt32FloatDictionary *)otherDictionary { 4686 if (otherDictionary) { 4687 [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 4688 if (_autocreator) { 4689 GPBAutocreatedDictionaryModified(_autocreator, self); 4690 } 4691 } 4692 } 4693 4694 - (void)setValue:(float)value forKey:(int32_t)key { 4695 [_dictionary setObject:@(value) forKey:@(key)]; 4696 if (_autocreator) { 4697 GPBAutocreatedDictionaryModified(_autocreator, self); 4698 } 4699 } 4700 4701 - (void)removeValueForKey:(int32_t)aKey { 4702 [_dictionary removeObjectForKey:@(aKey)]; 4703 } 4704 4705 - (void)removeAll { 4706 [_dictionary removeAllObjects]; 4707 } 4708 4709 @end 4710 4711 #pragma mark - Int32 -> Double 4712 4713 @implementation GPBInt32DoubleDictionary { 4714 @package 4715 NSMutableDictionary *_dictionary; 4716 } 4717 4718 + (instancetype)dictionary { 4719 return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; 4720 } 4721 4722 + (instancetype)dictionaryWithValue:(double)value 4723 forKey:(int32_t)key { 4724 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 4725 // on to get the type correct. 4726 return [[(GPBInt32DoubleDictionary*)[self alloc] initWithValues:&value 4727 forKeys:&key 4728 count:1] autorelease]; 4729 } 4730 4731 + (instancetype)dictionaryWithValues:(const double [])values 4732 forKeys:(const int32_t [])keys 4733 count:(NSUInteger)count { 4734 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 4735 // on to get the type correct. 4736 return [[(GPBInt32DoubleDictionary*)[self alloc] initWithValues:values 4737 forKeys:keys 4738 count:count] autorelease]; 4739 } 4740 4741 + (instancetype)dictionaryWithDictionary:(GPBInt32DoubleDictionary *)dictionary { 4742 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 4743 // on to get the type correct. 4744 return [[(GPBInt32DoubleDictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 4745 } 4746 4747 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 4748 return [[[self alloc] initWithCapacity:numItems] autorelease]; 4749 } 4750 4751 - (instancetype)init { 4752 return [self initWithValues:NULL forKeys:NULL count:0]; 4753 } 4754 4755 - (instancetype)initWithValues:(const double [])values 4756 forKeys:(const int32_t [])keys 4757 count:(NSUInteger)count { 4758 self = [super init]; 4759 if (self) { 4760 _dictionary = [[NSMutableDictionary alloc] init]; 4761 if (count && values && keys) { 4762 for (NSUInteger i = 0; i < count; ++i) { 4763 [_dictionary setObject:@(values[i]) forKey:@(keys[i])]; 4764 } 4765 } 4766 } 4767 return self; 4768 } 4769 4770 - (instancetype)initWithDictionary:(GPBInt32DoubleDictionary *)dictionary { 4771 self = [self initWithValues:NULL forKeys:NULL count:0]; 4772 if (self) { 4773 if (dictionary) { 4774 [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 4775 } 4776 } 4777 return self; 4778 } 4779 4780 - (instancetype)initWithCapacity:(NSUInteger)numItems { 4781 #pragma unused(numItems) 4782 return [self initWithValues:NULL forKeys:NULL count:0]; 4783 } 4784 4785 - (void)dealloc { 4786 NSAssert(!_autocreator, 4787 @"%@: Autocreator must be cleared before release, autocreator: %@", 4788 [self class], _autocreator); 4789 [_dictionary release]; 4790 [super dealloc]; 4791 } 4792 4793 - (instancetype)copyWithZone:(NSZone *)zone { 4794 return [[GPBInt32DoubleDictionary allocWithZone:zone] initWithDictionary:self]; 4795 } 4796 4797 - (BOOL)isEqual:(GPBInt32DoubleDictionary *)other { 4798 if (self == other) { 4799 return YES; 4800 } 4801 if (![other isKindOfClass:[GPBInt32DoubleDictionary class]]) { 4802 return NO; 4803 } 4804 return [_dictionary isEqual:other->_dictionary]; 4805 } 4806 4807 - (NSUInteger)hash { 4808 return _dictionary.count; 4809 } 4810 4811 - (NSString *)description { 4812 return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 4813 } 4814 4815 - (NSUInteger)count { 4816 return _dictionary.count; 4817 } 4818 4819 - (void)enumerateKeysAndValuesUsingBlock: 4820 (void (^)(int32_t key, double value, BOOL *stop))block { 4821 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 4822 NSNumber *aValue, 4823 BOOL *stop) { 4824 block([aKey intValue], [aValue doubleValue], stop); 4825 }]; 4826 } 4827 4828 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 4829 NSUInteger count = _dictionary.count; 4830 if (count == 0) { 4831 return 0; 4832 } 4833 4834 GPBDataType valueDataType = GPBGetFieldDataType(field); 4835 GPBDataType keyDataType = field.mapKeyDataType; 4836 __block size_t result = 0; 4837 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 4838 NSNumber *aValue, 4839 BOOL *stop) { 4840 #pragma unused(stop) 4841 size_t msgSize = ComputeDictInt32FieldSize([aKey intValue], kMapKeyFieldNumber, keyDataType); 4842 msgSize += ComputeDictDoubleFieldSize([aValue doubleValue], kMapValueFieldNumber, valueDataType); 4843 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 4844 }]; 4845 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 4846 result += tagSize * count; 4847 return result; 4848 } 4849 4850 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 4851 asField:(GPBFieldDescriptor *)field { 4852 GPBDataType valueDataType = GPBGetFieldDataType(field); 4853 GPBDataType keyDataType = field.mapKeyDataType; 4854 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 4855 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 4856 NSNumber *aValue, 4857 BOOL *stop) { 4858 #pragma unused(stop) 4859 // Write the tag. 4860 [outputStream writeInt32NoTag:tag]; 4861 // Write the size of the message. 4862 size_t msgSize = ComputeDictInt32FieldSize([aKey intValue], kMapKeyFieldNumber, keyDataType); 4863 msgSize += ComputeDictDoubleFieldSize([aValue doubleValue], kMapValueFieldNumber, valueDataType); 4864 [outputStream writeInt32NoTag:(int32_t)msgSize]; 4865 // Write the fields. 4866 WriteDictInt32Field(outputStream, [aKey intValue], kMapKeyFieldNumber, keyDataType); 4867 WriteDictDoubleField(outputStream, [aValue doubleValue], kMapValueFieldNumber, valueDataType); 4868 }]; 4869 } 4870 4871 - (void)setGPBGenericValue:(GPBGenericValue *)value 4872 forGPBGenericValueKey:(GPBGenericValue *)key { 4873 [_dictionary setObject:@(value->valueDouble) forKey:@(key->valueInt32)]; 4874 } 4875 4876 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 4877 [self enumerateKeysAndValuesUsingBlock:^(int32_t key, double value, BOOL *stop) { 4878 #pragma unused(stop) 4879 block([NSString stringWithFormat:@"%d", key], [NSString stringWithFormat:@"%.*lg", DBL_DIG, value]); 4880 }]; 4881 } 4882 4883 - (BOOL)valueForKey:(int32_t)key value:(double *)value { 4884 NSNumber *wrapped = [_dictionary objectForKey:@(key)]; 4885 if (wrapped && value) { 4886 *value = [wrapped doubleValue]; 4887 } 4888 return (wrapped != NULL); 4889 } 4890 4891 - (void)addEntriesFromDictionary:(GPBInt32DoubleDictionary *)otherDictionary { 4892 if (otherDictionary) { 4893 [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 4894 if (_autocreator) { 4895 GPBAutocreatedDictionaryModified(_autocreator, self); 4896 } 4897 } 4898 } 4899 4900 - (void)setValue:(double)value forKey:(int32_t)key { 4901 [_dictionary setObject:@(value) forKey:@(key)]; 4902 if (_autocreator) { 4903 GPBAutocreatedDictionaryModified(_autocreator, self); 4904 } 4905 } 4906 4907 - (void)removeValueForKey:(int32_t)aKey { 4908 [_dictionary removeObjectForKey:@(aKey)]; 4909 } 4910 4911 - (void)removeAll { 4912 [_dictionary removeAllObjects]; 4913 } 4914 4915 @end 4916 4917 #pragma mark - Int32 -> Enum 4918 4919 @implementation GPBInt32EnumDictionary { 4920 @package 4921 NSMutableDictionary *_dictionary; 4922 GPBEnumValidationFunc _validationFunc; 4923 } 4924 4925 @synthesize validationFunc = _validationFunc; 4926 4927 + (instancetype)dictionary { 4928 return [[[self alloc] initWithValidationFunction:NULL 4929 rawValues:NULL 4930 forKeys:NULL 4931 count:0] autorelease]; 4932 } 4933 4934 + (instancetype)dictionaryWithValidationFunction:(GPBEnumValidationFunc)func { 4935 return [[[self alloc] initWithValidationFunction:func 4936 rawValues:NULL 4937 forKeys:NULL 4938 count:0] autorelease]; 4939 } 4940 4941 + (instancetype)dictionaryWithValidationFunction:(GPBEnumValidationFunc)func 4942 rawValue:(int32_t)rawValue 4943 forKey:(int32_t)key { 4944 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 4945 // on to get the type correct. 4946 return [[(GPBInt32EnumDictionary*)[self alloc] initWithValidationFunction:func 4947 rawValues:&rawValue 4948 forKeys:&key 4949 count:1] autorelease]; 4950 } 4951 4952 + (instancetype)dictionaryWithValidationFunction:(GPBEnumValidationFunc)func 4953 rawValues:(const int32_t [])rawValues 4954 forKeys:(const int32_t [])keys 4955 count:(NSUInteger)count { 4956 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 4957 // on to get the type correct. 4958 return [[(GPBInt32EnumDictionary*)[self alloc] initWithValidationFunction:func 4959 rawValues:rawValues 4960 forKeys:keys 4961 count:count] autorelease]; 4962 } 4963 4964 + (instancetype)dictionaryWithDictionary:(GPBInt32EnumDictionary *)dictionary { 4965 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 4966 // on to get the type correct. 4967 return [[(GPBInt32EnumDictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 4968 } 4969 4970 + (instancetype)dictionaryWithValidationFunction:(GPBEnumValidationFunc)func 4971 capacity:(NSUInteger)numItems { 4972 return [[[self alloc] initWithValidationFunction:func capacity:numItems] autorelease]; 4973 } 4974 4975 - (instancetype)init { 4976 return [self initWithValidationFunction:NULL rawValues:NULL forKeys:NULL count:0]; 4977 } 4978 4979 - (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func { 4980 return [self initWithValidationFunction:func rawValues:NULL forKeys:NULL count:0]; 4981 } 4982 4983 - (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func 4984 rawValues:(const int32_t [])rawValues 4985 forKeys:(const int32_t [])keys 4986 count:(NSUInteger)count { 4987 self = [super init]; 4988 if (self) { 4989 _dictionary = [[NSMutableDictionary alloc] init]; 4990 _validationFunc = (func != NULL ? func : DictDefault_IsValidValue); 4991 if (count && rawValues && keys) { 4992 for (NSUInteger i = 0; i < count; ++i) { 4993 [_dictionary setObject:@(rawValues[i]) forKey:@(keys[i])]; 4994 } 4995 } 4996 } 4997 return self; 4998 } 4999 5000 - (instancetype)initWithDictionary:(GPBInt32EnumDictionary *)dictionary { 5001 self = [self initWithValidationFunction:dictionary.validationFunc 5002 rawValues:NULL 5003 forKeys:NULL 5004 count:0]; 5005 if (self) { 5006 if (dictionary) { 5007 [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 5008 } 5009 } 5010 return self; 5011 } 5012 5013 - (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func 5014 capacity:(NSUInteger)numItems { 5015 #pragma unused(numItems) 5016 return [self initWithValidationFunction:func rawValues:NULL forKeys:NULL count:0]; 5017 } 5018 5019 - (void)dealloc { 5020 NSAssert(!_autocreator, 5021 @"%@: Autocreator must be cleared before release, autocreator: %@", 5022 [self class], _autocreator); 5023 [_dictionary release]; 5024 [super dealloc]; 5025 } 5026 5027 - (instancetype)copyWithZone:(NSZone *)zone { 5028 return [[GPBInt32EnumDictionary allocWithZone:zone] initWithDictionary:self]; 5029 } 5030 5031 - (BOOL)isEqual:(GPBInt32EnumDictionary *)other { 5032 if (self == other) { 5033 return YES; 5034 } 5035 if (![other isKindOfClass:[GPBInt32EnumDictionary class]]) { 5036 return NO; 5037 } 5038 return [_dictionary isEqual:other->_dictionary]; 5039 } 5040 5041 - (NSUInteger)hash { 5042 return _dictionary.count; 5043 } 5044 5045 - (NSString *)description { 5046 return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 5047 } 5048 5049 - (NSUInteger)count { 5050 return _dictionary.count; 5051 } 5052 5053 - (void)enumerateKeysAndRawValuesUsingBlock: 5054 (void (^)(int32_t key, int32_t value, BOOL *stop))block { 5055 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 5056 NSNumber *aValue, 5057 BOOL *stop) { 5058 block([aKey intValue], [aValue intValue], stop); 5059 }]; 5060 } 5061 5062 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 5063 NSUInteger count = _dictionary.count; 5064 if (count == 0) { 5065 return 0; 5066 } 5067 5068 GPBDataType valueDataType = GPBGetFieldDataType(field); 5069 GPBDataType keyDataType = field.mapKeyDataType; 5070 __block size_t result = 0; 5071 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 5072 NSNumber *aValue, 5073 BOOL *stop) { 5074 #pragma unused(stop) 5075 size_t msgSize = ComputeDictInt32FieldSize([aKey intValue], kMapKeyFieldNumber, keyDataType); 5076 msgSize += ComputeDictEnumFieldSize([aValue intValue], kMapValueFieldNumber, valueDataType); 5077 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 5078 }]; 5079 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 5080 result += tagSize * count; 5081 return result; 5082 } 5083 5084 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 5085 asField:(GPBFieldDescriptor *)field { 5086 GPBDataType valueDataType = GPBGetFieldDataType(field); 5087 GPBDataType keyDataType = field.mapKeyDataType; 5088 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 5089 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 5090 NSNumber *aValue, 5091 BOOL *stop) { 5092 #pragma unused(stop) 5093 // Write the tag. 5094 [outputStream writeInt32NoTag:tag]; 5095 // Write the size of the message. 5096 size_t msgSize = ComputeDictInt32FieldSize([aKey intValue], kMapKeyFieldNumber, keyDataType); 5097 msgSize += ComputeDictEnumFieldSize([aValue intValue], kMapValueFieldNumber, valueDataType); 5098 [outputStream writeInt32NoTag:(int32_t)msgSize]; 5099 // Write the fields. 5100 WriteDictInt32Field(outputStream, [aKey intValue], kMapKeyFieldNumber, keyDataType); 5101 WriteDictEnumField(outputStream, [aValue intValue], kMapValueFieldNumber, valueDataType); 5102 }]; 5103 } 5104 5105 - (NSData *)serializedDataForUnknownValue:(int32_t)value 5106 forKey:(GPBGenericValue *)key 5107 keyDataType:(GPBDataType)keyDataType { 5108 size_t msgSize = ComputeDictInt32FieldSize(key->valueInt32, kMapKeyFieldNumber, keyDataType); 5109 msgSize += ComputeDictEnumFieldSize(value, kMapValueFieldNumber, GPBDataTypeEnum); 5110 NSMutableData *data = [NSMutableData dataWithLength:msgSize]; 5111 GPBCodedOutputStream *outputStream = [[GPBCodedOutputStream alloc] initWithData:data]; 5112 WriteDictInt32Field(outputStream, key->valueInt32, kMapKeyFieldNumber, keyDataType); 5113 WriteDictEnumField(outputStream, value, kMapValueFieldNumber, GPBDataTypeEnum); 5114 [outputStream release]; 5115 return data; 5116 } 5117 - (void)setGPBGenericValue:(GPBGenericValue *)value 5118 forGPBGenericValueKey:(GPBGenericValue *)key { 5119 [_dictionary setObject:@(value->valueEnum) forKey:@(key->valueInt32)]; 5120 } 5121 5122 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 5123 [self enumerateKeysAndRawValuesUsingBlock:^(int32_t key, int32_t value, BOOL *stop) { 5124 #pragma unused(stop) 5125 block([NSString stringWithFormat:@"%d", key], @(value)); 5126 }]; 5127 } 5128 5129 - (BOOL)valueForKey:(int32_t)key value:(int32_t *)value { 5130 NSNumber *wrapped = [_dictionary objectForKey:@(key)]; 5131 if (wrapped && value) { 5132 int32_t result = [wrapped intValue]; 5133 if (!_validationFunc(result)) { 5134 result = kGPBUnrecognizedEnumeratorValue; 5135 } 5136 *value = result; 5137 } 5138 return (wrapped != NULL); 5139 } 5140 5141 - (BOOL)valueForKey:(int32_t)key rawValue:(int32_t *)rawValue { 5142 NSNumber *wrapped = [_dictionary objectForKey:@(key)]; 5143 if (wrapped && rawValue) { 5144 *rawValue = [wrapped intValue]; 5145 } 5146 return (wrapped != NULL); 5147 } 5148 5149 - (void)enumerateKeysAndValuesUsingBlock: 5150 (void (^)(int32_t key, int32_t value, BOOL *stop))block { 5151 GPBEnumValidationFunc func = _validationFunc; 5152 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 5153 NSNumber *aValue, 5154 BOOL *stop) { 5155 int32_t unwrapped = [aValue intValue]; 5156 if (!func(unwrapped)) { 5157 unwrapped = kGPBUnrecognizedEnumeratorValue; 5158 } 5159 block([aKey intValue], unwrapped, stop); 5160 }]; 5161 } 5162 5163 - (void)addRawEntriesFromDictionary:(GPBInt32EnumDictionary *)otherDictionary { 5164 if (otherDictionary) { 5165 [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 5166 if (_autocreator) { 5167 GPBAutocreatedDictionaryModified(_autocreator, self); 5168 } 5169 } 5170 } 5171 5172 - (void)setRawValue:(int32_t)value forKey:(int32_t)key { 5173 [_dictionary setObject:@(value) forKey:@(key)]; 5174 if (_autocreator) { 5175 GPBAutocreatedDictionaryModified(_autocreator, self); 5176 } 5177 } 5178 5179 - (void)removeValueForKey:(int32_t)aKey { 5180 [_dictionary removeObjectForKey:@(aKey)]; 5181 } 5182 5183 - (void)removeAll { 5184 [_dictionary removeAllObjects]; 5185 } 5186 5187 - (void)setValue:(int32_t)value forKey:(int32_t)key { 5188 if (!_validationFunc(value)) { 5189 [NSException raise:NSInvalidArgumentException 5190 format:@"GPBInt32EnumDictionary: Attempt to set an unknown enum value (%d)", 5191 value]; 5192 } 5193 5194 [_dictionary setObject:@(value) forKey:@(key)]; 5195 if (_autocreator) { 5196 GPBAutocreatedDictionaryModified(_autocreator, self); 5197 } 5198 } 5199 5200 @end 5201 5202 #pragma mark - Int32 -> Object 5203 5204 @implementation GPBInt32ObjectDictionary { 5205 @package 5206 NSMutableDictionary *_dictionary; 5207 } 5208 5209 + (instancetype)dictionary { 5210 return [[[self alloc] initWithObjects:NULL forKeys:NULL count:0] autorelease]; 5211 } 5212 5213 + (instancetype)dictionaryWithObject:(id)object 5214 forKey:(int32_t)key { 5215 // Cast is needed so the compiler knows what class we are invoking initWithObjects:forKeys:count: 5216 // on to get the type correct. 5217 return [[(GPBInt32ObjectDictionary*)[self alloc] initWithObjects:&object 5218 forKeys:&key 5219 count:1] autorelease]; 5220 } 5221 5222 + (instancetype)dictionaryWithObjects:(const id [])objects 5223 forKeys:(const int32_t [])keys 5224 count:(NSUInteger)count { 5225 // Cast is needed so the compiler knows what class we are invoking initWithObjects:forKeys:count: 5226 // on to get the type correct. 5227 return [[(GPBInt32ObjectDictionary*)[self alloc] initWithObjects:objects 5228 forKeys:keys 5229 count:count] autorelease]; 5230 } 5231 5232 + (instancetype)dictionaryWithDictionary:(GPBInt32ObjectDictionary *)dictionary { 5233 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 5234 // on to get the type correct. 5235 return [[(GPBInt32ObjectDictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 5236 } 5237 5238 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 5239 return [[[self alloc] initWithCapacity:numItems] autorelease]; 5240 } 5241 5242 - (instancetype)init { 5243 return [self initWithObjects:NULL forKeys:NULL count:0]; 5244 } 5245 5246 - (instancetype)initWithObjects:(const id [])objects 5247 forKeys:(const int32_t [])keys 5248 count:(NSUInteger)count { 5249 self = [super init]; 5250 if (self) { 5251 _dictionary = [[NSMutableDictionary alloc] init]; 5252 if (count && objects && keys) { 5253 for (NSUInteger i = 0; i < count; ++i) { 5254 if (!objects[i]) { 5255 [NSException raise:NSInvalidArgumentException 5256 format:@"Attempting to add nil object to a Dictionary"]; 5257 } 5258 [_dictionary setObject:objects[i] forKey:@(keys[i])]; 5259 } 5260 } 5261 } 5262 return self; 5263 } 5264 5265 - (instancetype)initWithDictionary:(GPBInt32ObjectDictionary *)dictionary { 5266 self = [self initWithObjects:NULL forKeys:NULL count:0]; 5267 if (self) { 5268 if (dictionary) { 5269 [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 5270 } 5271 } 5272 return self; 5273 } 5274 5275 - (instancetype)initWithCapacity:(NSUInteger)numItems { 5276 #pragma unused(numItems) 5277 return [self initWithObjects:NULL forKeys:NULL count:0]; 5278 } 5279 5280 - (void)dealloc { 5281 NSAssert(!_autocreator, 5282 @"%@: Autocreator must be cleared before release, autocreator: %@", 5283 [self class], _autocreator); 5284 [_dictionary release]; 5285 [super dealloc]; 5286 } 5287 5288 - (instancetype)copyWithZone:(NSZone *)zone { 5289 return [[GPBInt32ObjectDictionary allocWithZone:zone] initWithDictionary:self]; 5290 } 5291 5292 - (BOOL)isEqual:(GPBInt32ObjectDictionary *)other { 5293 if (self == other) { 5294 return YES; 5295 } 5296 if (![other isKindOfClass:[GPBInt32ObjectDictionary class]]) { 5297 return NO; 5298 } 5299 return [_dictionary isEqual:other->_dictionary]; 5300 } 5301 5302 - (NSUInteger)hash { 5303 return _dictionary.count; 5304 } 5305 5306 - (NSString *)description { 5307 return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 5308 } 5309 5310 - (NSUInteger)count { 5311 return _dictionary.count; 5312 } 5313 5314 - (void)enumerateKeysAndObjectsUsingBlock: 5315 (void (^)(int32_t key, id object, BOOL *stop))block { 5316 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 5317 id aObject, 5318 BOOL *stop) { 5319 block([aKey intValue], aObject, stop); 5320 }]; 5321 } 5322 5323 - (BOOL)isInitialized { 5324 for (GPBMessage *msg in [_dictionary objectEnumerator]) { 5325 if (!msg.initialized) { 5326 return NO; 5327 } 5328 } 5329 return YES; 5330 } 5331 5332 - (instancetype)deepCopyWithZone:(NSZone *)zone { 5333 GPBInt32ObjectDictionary *newDict = 5334 [[GPBInt32ObjectDictionary alloc] init]; 5335 [_dictionary enumerateKeysAndObjectsUsingBlock:^(id aKey, 5336 GPBMessage *msg, 5337 BOOL *stop) { 5338 #pragma unused(stop) 5339 GPBMessage *copiedMsg = [msg copyWithZone:zone]; 5340 [newDict->_dictionary setObject:copiedMsg forKey:aKey]; 5341 [copiedMsg release]; 5342 }]; 5343 return newDict; 5344 } 5345 5346 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 5347 NSUInteger count = _dictionary.count; 5348 if (count == 0) { 5349 return 0; 5350 } 5351 5352 GPBDataType valueDataType = GPBGetFieldDataType(field); 5353 GPBDataType keyDataType = field.mapKeyDataType; 5354 __block size_t result = 0; 5355 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 5356 id aObject, 5357 BOOL *stop) { 5358 #pragma unused(stop) 5359 size_t msgSize = ComputeDictInt32FieldSize([aKey intValue], kMapKeyFieldNumber, keyDataType); 5360 msgSize += ComputeDictObjectFieldSize(aObject, kMapValueFieldNumber, valueDataType); 5361 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 5362 }]; 5363 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 5364 result += tagSize * count; 5365 return result; 5366 } 5367 5368 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 5369 asField:(GPBFieldDescriptor *)field { 5370 GPBDataType valueDataType = GPBGetFieldDataType(field); 5371 GPBDataType keyDataType = field.mapKeyDataType; 5372 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 5373 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 5374 id aObject, 5375 BOOL *stop) { 5376 #pragma unused(stop) 5377 // Write the tag. 5378 [outputStream writeInt32NoTag:tag]; 5379 // Write the size of the message. 5380 size_t msgSize = ComputeDictInt32FieldSize([aKey intValue], kMapKeyFieldNumber, keyDataType); 5381 msgSize += ComputeDictObjectFieldSize(aObject, kMapValueFieldNumber, valueDataType); 5382 [outputStream writeInt32NoTag:(int32_t)msgSize]; 5383 // Write the fields. 5384 WriteDictInt32Field(outputStream, [aKey intValue], kMapKeyFieldNumber, keyDataType); 5385 WriteDictObjectField(outputStream, aObject, kMapValueFieldNumber, valueDataType); 5386 }]; 5387 } 5388 5389 - (void)setGPBGenericValue:(GPBGenericValue *)value 5390 forGPBGenericValueKey:(GPBGenericValue *)key { 5391 [_dictionary setObject:value->valueString forKey:@(key->valueInt32)]; 5392 } 5393 5394 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 5395 [self enumerateKeysAndObjectsUsingBlock:^(int32_t key, id object, BOOL *stop) { 5396 #pragma unused(stop) 5397 block([NSString stringWithFormat:@"%d", key], object); 5398 }]; 5399 } 5400 5401 - (id)objectForKey:(int32_t)key { 5402 id result = [_dictionary objectForKey:@(key)]; 5403 return result; 5404 } 5405 5406 - (void)addEntriesFromDictionary:(GPBInt32ObjectDictionary *)otherDictionary { 5407 if (otherDictionary) { 5408 [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 5409 if (_autocreator) { 5410 GPBAutocreatedDictionaryModified(_autocreator, self); 5411 } 5412 } 5413 } 5414 5415 - (void)setObject:(id)object forKey:(int32_t)key { 5416 if (!object) { 5417 [NSException raise:NSInvalidArgumentException 5418 format:@"Attempting to add nil object to a Dictionary"]; 5419 } 5420 [_dictionary setObject:object forKey:@(key)]; 5421 if (_autocreator) { 5422 GPBAutocreatedDictionaryModified(_autocreator, self); 5423 } 5424 } 5425 5426 - (void)removeObjectForKey:(int32_t)aKey { 5427 [_dictionary removeObjectForKey:@(aKey)]; 5428 } 5429 5430 - (void)removeAll { 5431 [_dictionary removeAllObjects]; 5432 } 5433 5434 @end 5435 5436 //%PDDM-EXPAND DICTIONARY_IMPL_FOR_POD_KEY(UInt64, uint64_t) 5437 // This block of code is generated, do not edit it directly. 5438 5439 #pragma mark - UInt64 -> UInt32 5440 5441 @implementation GPBUInt64UInt32Dictionary { 5442 @package 5443 NSMutableDictionary *_dictionary; 5444 } 5445 5446 + (instancetype)dictionary { 5447 return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; 5448 } 5449 5450 + (instancetype)dictionaryWithValue:(uint32_t)value 5451 forKey:(uint64_t)key { 5452 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 5453 // on to get the type correct. 5454 return [[(GPBUInt64UInt32Dictionary*)[self alloc] initWithValues:&value 5455 forKeys:&key 5456 count:1] autorelease]; 5457 } 5458 5459 + (instancetype)dictionaryWithValues:(const uint32_t [])values 5460 forKeys:(const uint64_t [])keys 5461 count:(NSUInteger)count { 5462 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 5463 // on to get the type correct. 5464 return [[(GPBUInt64UInt32Dictionary*)[self alloc] initWithValues:values 5465 forKeys:keys 5466 count:count] autorelease]; 5467 } 5468 5469 + (instancetype)dictionaryWithDictionary:(GPBUInt64UInt32Dictionary *)dictionary { 5470 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 5471 // on to get the type correct. 5472 return [[(GPBUInt64UInt32Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 5473 } 5474 5475 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 5476 return [[[self alloc] initWithCapacity:numItems] autorelease]; 5477 } 5478 5479 - (instancetype)init { 5480 return [self initWithValues:NULL forKeys:NULL count:0]; 5481 } 5482 5483 - (instancetype)initWithValues:(const uint32_t [])values 5484 forKeys:(const uint64_t [])keys 5485 count:(NSUInteger)count { 5486 self = [super init]; 5487 if (self) { 5488 _dictionary = [[NSMutableDictionary alloc] init]; 5489 if (count && values && keys) { 5490 for (NSUInteger i = 0; i < count; ++i) { 5491 [_dictionary setObject:@(values[i]) forKey:@(keys[i])]; 5492 } 5493 } 5494 } 5495 return self; 5496 } 5497 5498 - (instancetype)initWithDictionary:(GPBUInt64UInt32Dictionary *)dictionary { 5499 self = [self initWithValues:NULL forKeys:NULL count:0]; 5500 if (self) { 5501 if (dictionary) { 5502 [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 5503 } 5504 } 5505 return self; 5506 } 5507 5508 - (instancetype)initWithCapacity:(NSUInteger)numItems { 5509 #pragma unused(numItems) 5510 return [self initWithValues:NULL forKeys:NULL count:0]; 5511 } 5512 5513 - (void)dealloc { 5514 NSAssert(!_autocreator, 5515 @"%@: Autocreator must be cleared before release, autocreator: %@", 5516 [self class], _autocreator); 5517 [_dictionary release]; 5518 [super dealloc]; 5519 } 5520 5521 - (instancetype)copyWithZone:(NSZone *)zone { 5522 return [[GPBUInt64UInt32Dictionary allocWithZone:zone] initWithDictionary:self]; 5523 } 5524 5525 - (BOOL)isEqual:(GPBUInt64UInt32Dictionary *)other { 5526 if (self == other) { 5527 return YES; 5528 } 5529 if (![other isKindOfClass:[GPBUInt64UInt32Dictionary class]]) { 5530 return NO; 5531 } 5532 return [_dictionary isEqual:other->_dictionary]; 5533 } 5534 5535 - (NSUInteger)hash { 5536 return _dictionary.count; 5537 } 5538 5539 - (NSString *)description { 5540 return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 5541 } 5542 5543 - (NSUInteger)count { 5544 return _dictionary.count; 5545 } 5546 5547 - (void)enumerateKeysAndValuesUsingBlock: 5548 (void (^)(uint64_t key, uint32_t value, BOOL *stop))block { 5549 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 5550 NSNumber *aValue, 5551 BOOL *stop) { 5552 block([aKey unsignedLongLongValue], [aValue unsignedIntValue], stop); 5553 }]; 5554 } 5555 5556 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 5557 NSUInteger count = _dictionary.count; 5558 if (count == 0) { 5559 return 0; 5560 } 5561 5562 GPBDataType valueDataType = GPBGetFieldDataType(field); 5563 GPBDataType keyDataType = field.mapKeyDataType; 5564 __block size_t result = 0; 5565 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 5566 NSNumber *aValue, 5567 BOOL *stop) { 5568 #pragma unused(stop) 5569 size_t msgSize = ComputeDictUInt64FieldSize([aKey unsignedLongLongValue], kMapKeyFieldNumber, keyDataType); 5570 msgSize += ComputeDictUInt32FieldSize([aValue unsignedIntValue], kMapValueFieldNumber, valueDataType); 5571 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 5572 }]; 5573 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 5574 result += tagSize * count; 5575 return result; 5576 } 5577 5578 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 5579 asField:(GPBFieldDescriptor *)field { 5580 GPBDataType valueDataType = GPBGetFieldDataType(field); 5581 GPBDataType keyDataType = field.mapKeyDataType; 5582 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 5583 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 5584 NSNumber *aValue, 5585 BOOL *stop) { 5586 #pragma unused(stop) 5587 // Write the tag. 5588 [outputStream writeInt32NoTag:tag]; 5589 // Write the size of the message. 5590 size_t msgSize = ComputeDictUInt64FieldSize([aKey unsignedLongLongValue], kMapKeyFieldNumber, keyDataType); 5591 msgSize += ComputeDictUInt32FieldSize([aValue unsignedIntValue], kMapValueFieldNumber, valueDataType); 5592 [outputStream writeInt32NoTag:(int32_t)msgSize]; 5593 // Write the fields. 5594 WriteDictUInt64Field(outputStream, [aKey unsignedLongLongValue], kMapKeyFieldNumber, keyDataType); 5595 WriteDictUInt32Field(outputStream, [aValue unsignedIntValue], kMapValueFieldNumber, valueDataType); 5596 }]; 5597 } 5598 5599 - (void)setGPBGenericValue:(GPBGenericValue *)value 5600 forGPBGenericValueKey:(GPBGenericValue *)key { 5601 [_dictionary setObject:@(value->valueUInt32) forKey:@(key->valueUInt64)]; 5602 } 5603 5604 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 5605 [self enumerateKeysAndValuesUsingBlock:^(uint64_t key, uint32_t value, BOOL *stop) { 5606 #pragma unused(stop) 5607 block([NSString stringWithFormat:@"%llu", key], [NSString stringWithFormat:@"%u", value]); 5608 }]; 5609 } 5610 5611 - (BOOL)valueForKey:(uint64_t)key value:(uint32_t *)value { 5612 NSNumber *wrapped = [_dictionary objectForKey:@(key)]; 5613 if (wrapped && value) { 5614 *value = [wrapped unsignedIntValue]; 5615 } 5616 return (wrapped != NULL); 5617 } 5618 5619 - (void)addEntriesFromDictionary:(GPBUInt64UInt32Dictionary *)otherDictionary { 5620 if (otherDictionary) { 5621 [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 5622 if (_autocreator) { 5623 GPBAutocreatedDictionaryModified(_autocreator, self); 5624 } 5625 } 5626 } 5627 5628 - (void)setValue:(uint32_t)value forKey:(uint64_t)key { 5629 [_dictionary setObject:@(value) forKey:@(key)]; 5630 if (_autocreator) { 5631 GPBAutocreatedDictionaryModified(_autocreator, self); 5632 } 5633 } 5634 5635 - (void)removeValueForKey:(uint64_t)aKey { 5636 [_dictionary removeObjectForKey:@(aKey)]; 5637 } 5638 5639 - (void)removeAll { 5640 [_dictionary removeAllObjects]; 5641 } 5642 5643 @end 5644 5645 #pragma mark - UInt64 -> Int32 5646 5647 @implementation GPBUInt64Int32Dictionary { 5648 @package 5649 NSMutableDictionary *_dictionary; 5650 } 5651 5652 + (instancetype)dictionary { 5653 return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; 5654 } 5655 5656 + (instancetype)dictionaryWithValue:(int32_t)value 5657 forKey:(uint64_t)key { 5658 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 5659 // on to get the type correct. 5660 return [[(GPBUInt64Int32Dictionary*)[self alloc] initWithValues:&value 5661 forKeys:&key 5662 count:1] autorelease]; 5663 } 5664 5665 + (instancetype)dictionaryWithValues:(const int32_t [])values 5666 forKeys:(const uint64_t [])keys 5667 count:(NSUInteger)count { 5668 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 5669 // on to get the type correct. 5670 return [[(GPBUInt64Int32Dictionary*)[self alloc] initWithValues:values 5671 forKeys:keys 5672 count:count] autorelease]; 5673 } 5674 5675 + (instancetype)dictionaryWithDictionary:(GPBUInt64Int32Dictionary *)dictionary { 5676 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 5677 // on to get the type correct. 5678 return [[(GPBUInt64Int32Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 5679 } 5680 5681 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 5682 return [[[self alloc] initWithCapacity:numItems] autorelease]; 5683 } 5684 5685 - (instancetype)init { 5686 return [self initWithValues:NULL forKeys:NULL count:0]; 5687 } 5688 5689 - (instancetype)initWithValues:(const int32_t [])values 5690 forKeys:(const uint64_t [])keys 5691 count:(NSUInteger)count { 5692 self = [super init]; 5693 if (self) { 5694 _dictionary = [[NSMutableDictionary alloc] init]; 5695 if (count && values && keys) { 5696 for (NSUInteger i = 0; i < count; ++i) { 5697 [_dictionary setObject:@(values[i]) forKey:@(keys[i])]; 5698 } 5699 } 5700 } 5701 return self; 5702 } 5703 5704 - (instancetype)initWithDictionary:(GPBUInt64Int32Dictionary *)dictionary { 5705 self = [self initWithValues:NULL forKeys:NULL count:0]; 5706 if (self) { 5707 if (dictionary) { 5708 [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 5709 } 5710 } 5711 return self; 5712 } 5713 5714 - (instancetype)initWithCapacity:(NSUInteger)numItems { 5715 #pragma unused(numItems) 5716 return [self initWithValues:NULL forKeys:NULL count:0]; 5717 } 5718 5719 - (void)dealloc { 5720 NSAssert(!_autocreator, 5721 @"%@: Autocreator must be cleared before release, autocreator: %@", 5722 [self class], _autocreator); 5723 [_dictionary release]; 5724 [super dealloc]; 5725 } 5726 5727 - (instancetype)copyWithZone:(NSZone *)zone { 5728 return [[GPBUInt64Int32Dictionary allocWithZone:zone] initWithDictionary:self]; 5729 } 5730 5731 - (BOOL)isEqual:(GPBUInt64Int32Dictionary *)other { 5732 if (self == other) { 5733 return YES; 5734 } 5735 if (![other isKindOfClass:[GPBUInt64Int32Dictionary class]]) { 5736 return NO; 5737 } 5738 return [_dictionary isEqual:other->_dictionary]; 5739 } 5740 5741 - (NSUInteger)hash { 5742 return _dictionary.count; 5743 } 5744 5745 - (NSString *)description { 5746 return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 5747 } 5748 5749 - (NSUInteger)count { 5750 return _dictionary.count; 5751 } 5752 5753 - (void)enumerateKeysAndValuesUsingBlock: 5754 (void (^)(uint64_t key, int32_t value, BOOL *stop))block { 5755 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 5756 NSNumber *aValue, 5757 BOOL *stop) { 5758 block([aKey unsignedLongLongValue], [aValue intValue], stop); 5759 }]; 5760 } 5761 5762 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 5763 NSUInteger count = _dictionary.count; 5764 if (count == 0) { 5765 return 0; 5766 } 5767 5768 GPBDataType valueDataType = GPBGetFieldDataType(field); 5769 GPBDataType keyDataType = field.mapKeyDataType; 5770 __block size_t result = 0; 5771 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 5772 NSNumber *aValue, 5773 BOOL *stop) { 5774 #pragma unused(stop) 5775 size_t msgSize = ComputeDictUInt64FieldSize([aKey unsignedLongLongValue], kMapKeyFieldNumber, keyDataType); 5776 msgSize += ComputeDictInt32FieldSize([aValue intValue], kMapValueFieldNumber, valueDataType); 5777 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 5778 }]; 5779 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 5780 result += tagSize * count; 5781 return result; 5782 } 5783 5784 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 5785 asField:(GPBFieldDescriptor *)field { 5786 GPBDataType valueDataType = GPBGetFieldDataType(field); 5787 GPBDataType keyDataType = field.mapKeyDataType; 5788 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 5789 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 5790 NSNumber *aValue, 5791 BOOL *stop) { 5792 #pragma unused(stop) 5793 // Write the tag. 5794 [outputStream writeInt32NoTag:tag]; 5795 // Write the size of the message. 5796 size_t msgSize = ComputeDictUInt64FieldSize([aKey unsignedLongLongValue], kMapKeyFieldNumber, keyDataType); 5797 msgSize += ComputeDictInt32FieldSize([aValue intValue], kMapValueFieldNumber, valueDataType); 5798 [outputStream writeInt32NoTag:(int32_t)msgSize]; 5799 // Write the fields. 5800 WriteDictUInt64Field(outputStream, [aKey unsignedLongLongValue], kMapKeyFieldNumber, keyDataType); 5801 WriteDictInt32Field(outputStream, [aValue intValue], kMapValueFieldNumber, valueDataType); 5802 }]; 5803 } 5804 5805 - (void)setGPBGenericValue:(GPBGenericValue *)value 5806 forGPBGenericValueKey:(GPBGenericValue *)key { 5807 [_dictionary setObject:@(value->valueInt32) forKey:@(key->valueUInt64)]; 5808 } 5809 5810 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 5811 [self enumerateKeysAndValuesUsingBlock:^(uint64_t key, int32_t value, BOOL *stop) { 5812 #pragma unused(stop) 5813 block([NSString stringWithFormat:@"%llu", key], [NSString stringWithFormat:@"%d", value]); 5814 }]; 5815 } 5816 5817 - (BOOL)valueForKey:(uint64_t)key value:(int32_t *)value { 5818 NSNumber *wrapped = [_dictionary objectForKey:@(key)]; 5819 if (wrapped && value) { 5820 *value = [wrapped intValue]; 5821 } 5822 return (wrapped != NULL); 5823 } 5824 5825 - (void)addEntriesFromDictionary:(GPBUInt64Int32Dictionary *)otherDictionary { 5826 if (otherDictionary) { 5827 [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 5828 if (_autocreator) { 5829 GPBAutocreatedDictionaryModified(_autocreator, self); 5830 } 5831 } 5832 } 5833 5834 - (void)setValue:(int32_t)value forKey:(uint64_t)key { 5835 [_dictionary setObject:@(value) forKey:@(key)]; 5836 if (_autocreator) { 5837 GPBAutocreatedDictionaryModified(_autocreator, self); 5838 } 5839 } 5840 5841 - (void)removeValueForKey:(uint64_t)aKey { 5842 [_dictionary removeObjectForKey:@(aKey)]; 5843 } 5844 5845 - (void)removeAll { 5846 [_dictionary removeAllObjects]; 5847 } 5848 5849 @end 5850 5851 #pragma mark - UInt64 -> UInt64 5852 5853 @implementation GPBUInt64UInt64Dictionary { 5854 @package 5855 NSMutableDictionary *_dictionary; 5856 } 5857 5858 + (instancetype)dictionary { 5859 return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; 5860 } 5861 5862 + (instancetype)dictionaryWithValue:(uint64_t)value 5863 forKey:(uint64_t)key { 5864 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 5865 // on to get the type correct. 5866 return [[(GPBUInt64UInt64Dictionary*)[self alloc] initWithValues:&value 5867 forKeys:&key 5868 count:1] autorelease]; 5869 } 5870 5871 + (instancetype)dictionaryWithValues:(const uint64_t [])values 5872 forKeys:(const uint64_t [])keys 5873 count:(NSUInteger)count { 5874 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 5875 // on to get the type correct. 5876 return [[(GPBUInt64UInt64Dictionary*)[self alloc] initWithValues:values 5877 forKeys:keys 5878 count:count] autorelease]; 5879 } 5880 5881 + (instancetype)dictionaryWithDictionary:(GPBUInt64UInt64Dictionary *)dictionary { 5882 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 5883 // on to get the type correct. 5884 return [[(GPBUInt64UInt64Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 5885 } 5886 5887 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 5888 return [[[self alloc] initWithCapacity:numItems] autorelease]; 5889 } 5890 5891 - (instancetype)init { 5892 return [self initWithValues:NULL forKeys:NULL count:0]; 5893 } 5894 5895 - (instancetype)initWithValues:(const uint64_t [])values 5896 forKeys:(const uint64_t [])keys 5897 count:(NSUInteger)count { 5898 self = [super init]; 5899 if (self) { 5900 _dictionary = [[NSMutableDictionary alloc] init]; 5901 if (count && values && keys) { 5902 for (NSUInteger i = 0; i < count; ++i) { 5903 [_dictionary setObject:@(values[i]) forKey:@(keys[i])]; 5904 } 5905 } 5906 } 5907 return self; 5908 } 5909 5910 - (instancetype)initWithDictionary:(GPBUInt64UInt64Dictionary *)dictionary { 5911 self = [self initWithValues:NULL forKeys:NULL count:0]; 5912 if (self) { 5913 if (dictionary) { 5914 [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 5915 } 5916 } 5917 return self; 5918 } 5919 5920 - (instancetype)initWithCapacity:(NSUInteger)numItems { 5921 #pragma unused(numItems) 5922 return [self initWithValues:NULL forKeys:NULL count:0]; 5923 } 5924 5925 - (void)dealloc { 5926 NSAssert(!_autocreator, 5927 @"%@: Autocreator must be cleared before release, autocreator: %@", 5928 [self class], _autocreator); 5929 [_dictionary release]; 5930 [super dealloc]; 5931 } 5932 5933 - (instancetype)copyWithZone:(NSZone *)zone { 5934 return [[GPBUInt64UInt64Dictionary allocWithZone:zone] initWithDictionary:self]; 5935 } 5936 5937 - (BOOL)isEqual:(GPBUInt64UInt64Dictionary *)other { 5938 if (self == other) { 5939 return YES; 5940 } 5941 if (![other isKindOfClass:[GPBUInt64UInt64Dictionary class]]) { 5942 return NO; 5943 } 5944 return [_dictionary isEqual:other->_dictionary]; 5945 } 5946 5947 - (NSUInteger)hash { 5948 return _dictionary.count; 5949 } 5950 5951 - (NSString *)description { 5952 return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 5953 } 5954 5955 - (NSUInteger)count { 5956 return _dictionary.count; 5957 } 5958 5959 - (void)enumerateKeysAndValuesUsingBlock: 5960 (void (^)(uint64_t key, uint64_t value, BOOL *stop))block { 5961 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 5962 NSNumber *aValue, 5963 BOOL *stop) { 5964 block([aKey unsignedLongLongValue], [aValue unsignedLongLongValue], stop); 5965 }]; 5966 } 5967 5968 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 5969 NSUInteger count = _dictionary.count; 5970 if (count == 0) { 5971 return 0; 5972 } 5973 5974 GPBDataType valueDataType = GPBGetFieldDataType(field); 5975 GPBDataType keyDataType = field.mapKeyDataType; 5976 __block size_t result = 0; 5977 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 5978 NSNumber *aValue, 5979 BOOL *stop) { 5980 #pragma unused(stop) 5981 size_t msgSize = ComputeDictUInt64FieldSize([aKey unsignedLongLongValue], kMapKeyFieldNumber, keyDataType); 5982 msgSize += ComputeDictUInt64FieldSize([aValue unsignedLongLongValue], kMapValueFieldNumber, valueDataType); 5983 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 5984 }]; 5985 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 5986 result += tagSize * count; 5987 return result; 5988 } 5989 5990 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 5991 asField:(GPBFieldDescriptor *)field { 5992 GPBDataType valueDataType = GPBGetFieldDataType(field); 5993 GPBDataType keyDataType = field.mapKeyDataType; 5994 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 5995 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 5996 NSNumber *aValue, 5997 BOOL *stop) { 5998 #pragma unused(stop) 5999 // Write the tag. 6000 [outputStream writeInt32NoTag:tag]; 6001 // Write the size of the message. 6002 size_t msgSize = ComputeDictUInt64FieldSize([aKey unsignedLongLongValue], kMapKeyFieldNumber, keyDataType); 6003 msgSize += ComputeDictUInt64FieldSize([aValue unsignedLongLongValue], kMapValueFieldNumber, valueDataType); 6004 [outputStream writeInt32NoTag:(int32_t)msgSize]; 6005 // Write the fields. 6006 WriteDictUInt64Field(outputStream, [aKey unsignedLongLongValue], kMapKeyFieldNumber, keyDataType); 6007 WriteDictUInt64Field(outputStream, [aValue unsignedLongLongValue], kMapValueFieldNumber, valueDataType); 6008 }]; 6009 } 6010 6011 - (void)setGPBGenericValue:(GPBGenericValue *)value 6012 forGPBGenericValueKey:(GPBGenericValue *)key { 6013 [_dictionary setObject:@(value->valueUInt64) forKey:@(key->valueUInt64)]; 6014 } 6015 6016 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 6017 [self enumerateKeysAndValuesUsingBlock:^(uint64_t key, uint64_t value, BOOL *stop) { 6018 #pragma unused(stop) 6019 block([NSString stringWithFormat:@"%llu", key], [NSString stringWithFormat:@"%llu", value]); 6020 }]; 6021 } 6022 6023 - (BOOL)valueForKey:(uint64_t)key value:(uint64_t *)value { 6024 NSNumber *wrapped = [_dictionary objectForKey:@(key)]; 6025 if (wrapped && value) { 6026 *value = [wrapped unsignedLongLongValue]; 6027 } 6028 return (wrapped != NULL); 6029 } 6030 6031 - (void)addEntriesFromDictionary:(GPBUInt64UInt64Dictionary *)otherDictionary { 6032 if (otherDictionary) { 6033 [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 6034 if (_autocreator) { 6035 GPBAutocreatedDictionaryModified(_autocreator, self); 6036 } 6037 } 6038 } 6039 6040 - (void)setValue:(uint64_t)value forKey:(uint64_t)key { 6041 [_dictionary setObject:@(value) forKey:@(key)]; 6042 if (_autocreator) { 6043 GPBAutocreatedDictionaryModified(_autocreator, self); 6044 } 6045 } 6046 6047 - (void)removeValueForKey:(uint64_t)aKey { 6048 [_dictionary removeObjectForKey:@(aKey)]; 6049 } 6050 6051 - (void)removeAll { 6052 [_dictionary removeAllObjects]; 6053 } 6054 6055 @end 6056 6057 #pragma mark - UInt64 -> Int64 6058 6059 @implementation GPBUInt64Int64Dictionary { 6060 @package 6061 NSMutableDictionary *_dictionary; 6062 } 6063 6064 + (instancetype)dictionary { 6065 return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; 6066 } 6067 6068 + (instancetype)dictionaryWithValue:(int64_t)value 6069 forKey:(uint64_t)key { 6070 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 6071 // on to get the type correct. 6072 return [[(GPBUInt64Int64Dictionary*)[self alloc] initWithValues:&value 6073 forKeys:&key 6074 count:1] autorelease]; 6075 } 6076 6077 + (instancetype)dictionaryWithValues:(const int64_t [])values 6078 forKeys:(const uint64_t [])keys 6079 count:(NSUInteger)count { 6080 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 6081 // on to get the type correct. 6082 return [[(GPBUInt64Int64Dictionary*)[self alloc] initWithValues:values 6083 forKeys:keys 6084 count:count] autorelease]; 6085 } 6086 6087 + (instancetype)dictionaryWithDictionary:(GPBUInt64Int64Dictionary *)dictionary { 6088 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 6089 // on to get the type correct. 6090 return [[(GPBUInt64Int64Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 6091 } 6092 6093 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 6094 return [[[self alloc] initWithCapacity:numItems] autorelease]; 6095 } 6096 6097 - (instancetype)init { 6098 return [self initWithValues:NULL forKeys:NULL count:0]; 6099 } 6100 6101 - (instancetype)initWithValues:(const int64_t [])values 6102 forKeys:(const uint64_t [])keys 6103 count:(NSUInteger)count { 6104 self = [super init]; 6105 if (self) { 6106 _dictionary = [[NSMutableDictionary alloc] init]; 6107 if (count && values && keys) { 6108 for (NSUInteger i = 0; i < count; ++i) { 6109 [_dictionary setObject:@(values[i]) forKey:@(keys[i])]; 6110 } 6111 } 6112 } 6113 return self; 6114 } 6115 6116 - (instancetype)initWithDictionary:(GPBUInt64Int64Dictionary *)dictionary { 6117 self = [self initWithValues:NULL forKeys:NULL count:0]; 6118 if (self) { 6119 if (dictionary) { 6120 [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 6121 } 6122 } 6123 return self; 6124 } 6125 6126 - (instancetype)initWithCapacity:(NSUInteger)numItems { 6127 #pragma unused(numItems) 6128 return [self initWithValues:NULL forKeys:NULL count:0]; 6129 } 6130 6131 - (void)dealloc { 6132 NSAssert(!_autocreator, 6133 @"%@: Autocreator must be cleared before release, autocreator: %@", 6134 [self class], _autocreator); 6135 [_dictionary release]; 6136 [super dealloc]; 6137 } 6138 6139 - (instancetype)copyWithZone:(NSZone *)zone { 6140 return [[GPBUInt64Int64Dictionary allocWithZone:zone] initWithDictionary:self]; 6141 } 6142 6143 - (BOOL)isEqual:(GPBUInt64Int64Dictionary *)other { 6144 if (self == other) { 6145 return YES; 6146 } 6147 if (![other isKindOfClass:[GPBUInt64Int64Dictionary class]]) { 6148 return NO; 6149 } 6150 return [_dictionary isEqual:other->_dictionary]; 6151 } 6152 6153 - (NSUInteger)hash { 6154 return _dictionary.count; 6155 } 6156 6157 - (NSString *)description { 6158 return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 6159 } 6160 6161 - (NSUInteger)count { 6162 return _dictionary.count; 6163 } 6164 6165 - (void)enumerateKeysAndValuesUsingBlock: 6166 (void (^)(uint64_t key, int64_t value, BOOL *stop))block { 6167 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 6168 NSNumber *aValue, 6169 BOOL *stop) { 6170 block([aKey unsignedLongLongValue], [aValue longLongValue], stop); 6171 }]; 6172 } 6173 6174 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 6175 NSUInteger count = _dictionary.count; 6176 if (count == 0) { 6177 return 0; 6178 } 6179 6180 GPBDataType valueDataType = GPBGetFieldDataType(field); 6181 GPBDataType keyDataType = field.mapKeyDataType; 6182 __block size_t result = 0; 6183 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 6184 NSNumber *aValue, 6185 BOOL *stop) { 6186 #pragma unused(stop) 6187 size_t msgSize = ComputeDictUInt64FieldSize([aKey unsignedLongLongValue], kMapKeyFieldNumber, keyDataType); 6188 msgSize += ComputeDictInt64FieldSize([aValue longLongValue], kMapValueFieldNumber, valueDataType); 6189 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 6190 }]; 6191 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 6192 result += tagSize * count; 6193 return result; 6194 } 6195 6196 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 6197 asField:(GPBFieldDescriptor *)field { 6198 GPBDataType valueDataType = GPBGetFieldDataType(field); 6199 GPBDataType keyDataType = field.mapKeyDataType; 6200 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 6201 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 6202 NSNumber *aValue, 6203 BOOL *stop) { 6204 #pragma unused(stop) 6205 // Write the tag. 6206 [outputStream writeInt32NoTag:tag]; 6207 // Write the size of the message. 6208 size_t msgSize = ComputeDictUInt64FieldSize([aKey unsignedLongLongValue], kMapKeyFieldNumber, keyDataType); 6209 msgSize += ComputeDictInt64FieldSize([aValue longLongValue], kMapValueFieldNumber, valueDataType); 6210 [outputStream writeInt32NoTag:(int32_t)msgSize]; 6211 // Write the fields. 6212 WriteDictUInt64Field(outputStream, [aKey unsignedLongLongValue], kMapKeyFieldNumber, keyDataType); 6213 WriteDictInt64Field(outputStream, [aValue longLongValue], kMapValueFieldNumber, valueDataType); 6214 }]; 6215 } 6216 6217 - (void)setGPBGenericValue:(GPBGenericValue *)value 6218 forGPBGenericValueKey:(GPBGenericValue *)key { 6219 [_dictionary setObject:@(value->valueInt64) forKey:@(key->valueUInt64)]; 6220 } 6221 6222 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 6223 [self enumerateKeysAndValuesUsingBlock:^(uint64_t key, int64_t value, BOOL *stop) { 6224 #pragma unused(stop) 6225 block([NSString stringWithFormat:@"%llu", key], [NSString stringWithFormat:@"%lld", value]); 6226 }]; 6227 } 6228 6229 - (BOOL)valueForKey:(uint64_t)key value:(int64_t *)value { 6230 NSNumber *wrapped = [_dictionary objectForKey:@(key)]; 6231 if (wrapped && value) { 6232 *value = [wrapped longLongValue]; 6233 } 6234 return (wrapped != NULL); 6235 } 6236 6237 - (void)addEntriesFromDictionary:(GPBUInt64Int64Dictionary *)otherDictionary { 6238 if (otherDictionary) { 6239 [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 6240 if (_autocreator) { 6241 GPBAutocreatedDictionaryModified(_autocreator, self); 6242 } 6243 } 6244 } 6245 6246 - (void)setValue:(int64_t)value forKey:(uint64_t)key { 6247 [_dictionary setObject:@(value) forKey:@(key)]; 6248 if (_autocreator) { 6249 GPBAutocreatedDictionaryModified(_autocreator, self); 6250 } 6251 } 6252 6253 - (void)removeValueForKey:(uint64_t)aKey { 6254 [_dictionary removeObjectForKey:@(aKey)]; 6255 } 6256 6257 - (void)removeAll { 6258 [_dictionary removeAllObjects]; 6259 } 6260 6261 @end 6262 6263 #pragma mark - UInt64 -> Bool 6264 6265 @implementation GPBUInt64BoolDictionary { 6266 @package 6267 NSMutableDictionary *_dictionary; 6268 } 6269 6270 + (instancetype)dictionary { 6271 return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; 6272 } 6273 6274 + (instancetype)dictionaryWithValue:(BOOL)value 6275 forKey:(uint64_t)key { 6276 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 6277 // on to get the type correct. 6278 return [[(GPBUInt64BoolDictionary*)[self alloc] initWithValues:&value 6279 forKeys:&key 6280 count:1] autorelease]; 6281 } 6282 6283 + (instancetype)dictionaryWithValues:(const BOOL [])values 6284 forKeys:(const uint64_t [])keys 6285 count:(NSUInteger)count { 6286 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 6287 // on to get the type correct. 6288 return [[(GPBUInt64BoolDictionary*)[self alloc] initWithValues:values 6289 forKeys:keys 6290 count:count] autorelease]; 6291 } 6292 6293 + (instancetype)dictionaryWithDictionary:(GPBUInt64BoolDictionary *)dictionary { 6294 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 6295 // on to get the type correct. 6296 return [[(GPBUInt64BoolDictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 6297 } 6298 6299 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 6300 return [[[self alloc] initWithCapacity:numItems] autorelease]; 6301 } 6302 6303 - (instancetype)init { 6304 return [self initWithValues:NULL forKeys:NULL count:0]; 6305 } 6306 6307 - (instancetype)initWithValues:(const BOOL [])values 6308 forKeys:(const uint64_t [])keys 6309 count:(NSUInteger)count { 6310 self = [super init]; 6311 if (self) { 6312 _dictionary = [[NSMutableDictionary alloc] init]; 6313 if (count && values && keys) { 6314 for (NSUInteger i = 0; i < count; ++i) { 6315 [_dictionary setObject:@(values[i]) forKey:@(keys[i])]; 6316 } 6317 } 6318 } 6319 return self; 6320 } 6321 6322 - (instancetype)initWithDictionary:(GPBUInt64BoolDictionary *)dictionary { 6323 self = [self initWithValues:NULL forKeys:NULL count:0]; 6324 if (self) { 6325 if (dictionary) { 6326 [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 6327 } 6328 } 6329 return self; 6330 } 6331 6332 - (instancetype)initWithCapacity:(NSUInteger)numItems { 6333 #pragma unused(numItems) 6334 return [self initWithValues:NULL forKeys:NULL count:0]; 6335 } 6336 6337 - (void)dealloc { 6338 NSAssert(!_autocreator, 6339 @"%@: Autocreator must be cleared before release, autocreator: %@", 6340 [self class], _autocreator); 6341 [_dictionary release]; 6342 [super dealloc]; 6343 } 6344 6345 - (instancetype)copyWithZone:(NSZone *)zone { 6346 return [[GPBUInt64BoolDictionary allocWithZone:zone] initWithDictionary:self]; 6347 } 6348 6349 - (BOOL)isEqual:(GPBUInt64BoolDictionary *)other { 6350 if (self == other) { 6351 return YES; 6352 } 6353 if (![other isKindOfClass:[GPBUInt64BoolDictionary class]]) { 6354 return NO; 6355 } 6356 return [_dictionary isEqual:other->_dictionary]; 6357 } 6358 6359 - (NSUInteger)hash { 6360 return _dictionary.count; 6361 } 6362 6363 - (NSString *)description { 6364 return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 6365 } 6366 6367 - (NSUInteger)count { 6368 return _dictionary.count; 6369 } 6370 6371 - (void)enumerateKeysAndValuesUsingBlock: 6372 (void (^)(uint64_t key, BOOL value, BOOL *stop))block { 6373 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 6374 NSNumber *aValue, 6375 BOOL *stop) { 6376 block([aKey unsignedLongLongValue], [aValue boolValue], stop); 6377 }]; 6378 } 6379 6380 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 6381 NSUInteger count = _dictionary.count; 6382 if (count == 0) { 6383 return 0; 6384 } 6385 6386 GPBDataType valueDataType = GPBGetFieldDataType(field); 6387 GPBDataType keyDataType = field.mapKeyDataType; 6388 __block size_t result = 0; 6389 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 6390 NSNumber *aValue, 6391 BOOL *stop) { 6392 #pragma unused(stop) 6393 size_t msgSize = ComputeDictUInt64FieldSize([aKey unsignedLongLongValue], kMapKeyFieldNumber, keyDataType); 6394 msgSize += ComputeDictBoolFieldSize([aValue boolValue], kMapValueFieldNumber, valueDataType); 6395 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 6396 }]; 6397 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 6398 result += tagSize * count; 6399 return result; 6400 } 6401 6402 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 6403 asField:(GPBFieldDescriptor *)field { 6404 GPBDataType valueDataType = GPBGetFieldDataType(field); 6405 GPBDataType keyDataType = field.mapKeyDataType; 6406 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 6407 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 6408 NSNumber *aValue, 6409 BOOL *stop) { 6410 #pragma unused(stop) 6411 // Write the tag. 6412 [outputStream writeInt32NoTag:tag]; 6413 // Write the size of the message. 6414 size_t msgSize = ComputeDictUInt64FieldSize([aKey unsignedLongLongValue], kMapKeyFieldNumber, keyDataType); 6415 msgSize += ComputeDictBoolFieldSize([aValue boolValue], kMapValueFieldNumber, valueDataType); 6416 [outputStream writeInt32NoTag:(int32_t)msgSize]; 6417 // Write the fields. 6418 WriteDictUInt64Field(outputStream, [aKey unsignedLongLongValue], kMapKeyFieldNumber, keyDataType); 6419 WriteDictBoolField(outputStream, [aValue boolValue], kMapValueFieldNumber, valueDataType); 6420 }]; 6421 } 6422 6423 - (void)setGPBGenericValue:(GPBGenericValue *)value 6424 forGPBGenericValueKey:(GPBGenericValue *)key { 6425 [_dictionary setObject:@(value->valueBool) forKey:@(key->valueUInt64)]; 6426 } 6427 6428 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 6429 [self enumerateKeysAndValuesUsingBlock:^(uint64_t key, BOOL value, BOOL *stop) { 6430 #pragma unused(stop) 6431 block([NSString stringWithFormat:@"%llu", key], (value ? @"true" : @"false")); 6432 }]; 6433 } 6434 6435 - (BOOL)valueForKey:(uint64_t)key value:(BOOL *)value { 6436 NSNumber *wrapped = [_dictionary objectForKey:@(key)]; 6437 if (wrapped && value) { 6438 *value = [wrapped boolValue]; 6439 } 6440 return (wrapped != NULL); 6441 } 6442 6443 - (void)addEntriesFromDictionary:(GPBUInt64BoolDictionary *)otherDictionary { 6444 if (otherDictionary) { 6445 [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 6446 if (_autocreator) { 6447 GPBAutocreatedDictionaryModified(_autocreator, self); 6448 } 6449 } 6450 } 6451 6452 - (void)setValue:(BOOL)value forKey:(uint64_t)key { 6453 [_dictionary setObject:@(value) forKey:@(key)]; 6454 if (_autocreator) { 6455 GPBAutocreatedDictionaryModified(_autocreator, self); 6456 } 6457 } 6458 6459 - (void)removeValueForKey:(uint64_t)aKey { 6460 [_dictionary removeObjectForKey:@(aKey)]; 6461 } 6462 6463 - (void)removeAll { 6464 [_dictionary removeAllObjects]; 6465 } 6466 6467 @end 6468 6469 #pragma mark - UInt64 -> Float 6470 6471 @implementation GPBUInt64FloatDictionary { 6472 @package 6473 NSMutableDictionary *_dictionary; 6474 } 6475 6476 + (instancetype)dictionary { 6477 return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; 6478 } 6479 6480 + (instancetype)dictionaryWithValue:(float)value 6481 forKey:(uint64_t)key { 6482 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 6483 // on to get the type correct. 6484 return [[(GPBUInt64FloatDictionary*)[self alloc] initWithValues:&value 6485 forKeys:&key 6486 count:1] autorelease]; 6487 } 6488 6489 + (instancetype)dictionaryWithValues:(const float [])values 6490 forKeys:(const uint64_t [])keys 6491 count:(NSUInteger)count { 6492 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 6493 // on to get the type correct. 6494 return [[(GPBUInt64FloatDictionary*)[self alloc] initWithValues:values 6495 forKeys:keys 6496 count:count] autorelease]; 6497 } 6498 6499 + (instancetype)dictionaryWithDictionary:(GPBUInt64FloatDictionary *)dictionary { 6500 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 6501 // on to get the type correct. 6502 return [[(GPBUInt64FloatDictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 6503 } 6504 6505 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 6506 return [[[self alloc] initWithCapacity:numItems] autorelease]; 6507 } 6508 6509 - (instancetype)init { 6510 return [self initWithValues:NULL forKeys:NULL count:0]; 6511 } 6512 6513 - (instancetype)initWithValues:(const float [])values 6514 forKeys:(const uint64_t [])keys 6515 count:(NSUInteger)count { 6516 self = [super init]; 6517 if (self) { 6518 _dictionary = [[NSMutableDictionary alloc] init]; 6519 if (count && values && keys) { 6520 for (NSUInteger i = 0; i < count; ++i) { 6521 [_dictionary setObject:@(values[i]) forKey:@(keys[i])]; 6522 } 6523 } 6524 } 6525 return self; 6526 } 6527 6528 - (instancetype)initWithDictionary:(GPBUInt64FloatDictionary *)dictionary { 6529 self = [self initWithValues:NULL forKeys:NULL count:0]; 6530 if (self) { 6531 if (dictionary) { 6532 [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 6533 } 6534 } 6535 return self; 6536 } 6537 6538 - (instancetype)initWithCapacity:(NSUInteger)numItems { 6539 #pragma unused(numItems) 6540 return [self initWithValues:NULL forKeys:NULL count:0]; 6541 } 6542 6543 - (void)dealloc { 6544 NSAssert(!_autocreator, 6545 @"%@: Autocreator must be cleared before release, autocreator: %@", 6546 [self class], _autocreator); 6547 [_dictionary release]; 6548 [super dealloc]; 6549 } 6550 6551 - (instancetype)copyWithZone:(NSZone *)zone { 6552 return [[GPBUInt64FloatDictionary allocWithZone:zone] initWithDictionary:self]; 6553 } 6554 6555 - (BOOL)isEqual:(GPBUInt64FloatDictionary *)other { 6556 if (self == other) { 6557 return YES; 6558 } 6559 if (![other isKindOfClass:[GPBUInt64FloatDictionary class]]) { 6560 return NO; 6561 } 6562 return [_dictionary isEqual:other->_dictionary]; 6563 } 6564 6565 - (NSUInteger)hash { 6566 return _dictionary.count; 6567 } 6568 6569 - (NSString *)description { 6570 return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 6571 } 6572 6573 - (NSUInteger)count { 6574 return _dictionary.count; 6575 } 6576 6577 - (void)enumerateKeysAndValuesUsingBlock: 6578 (void (^)(uint64_t key, float value, BOOL *stop))block { 6579 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 6580 NSNumber *aValue, 6581 BOOL *stop) { 6582 block([aKey unsignedLongLongValue], [aValue floatValue], stop); 6583 }]; 6584 } 6585 6586 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 6587 NSUInteger count = _dictionary.count; 6588 if (count == 0) { 6589 return 0; 6590 } 6591 6592 GPBDataType valueDataType = GPBGetFieldDataType(field); 6593 GPBDataType keyDataType = field.mapKeyDataType; 6594 __block size_t result = 0; 6595 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 6596 NSNumber *aValue, 6597 BOOL *stop) { 6598 #pragma unused(stop) 6599 size_t msgSize = ComputeDictUInt64FieldSize([aKey unsignedLongLongValue], kMapKeyFieldNumber, keyDataType); 6600 msgSize += ComputeDictFloatFieldSize([aValue floatValue], kMapValueFieldNumber, valueDataType); 6601 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 6602 }]; 6603 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 6604 result += tagSize * count; 6605 return result; 6606 } 6607 6608 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 6609 asField:(GPBFieldDescriptor *)field { 6610 GPBDataType valueDataType = GPBGetFieldDataType(field); 6611 GPBDataType keyDataType = field.mapKeyDataType; 6612 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 6613 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 6614 NSNumber *aValue, 6615 BOOL *stop) { 6616 #pragma unused(stop) 6617 // Write the tag. 6618 [outputStream writeInt32NoTag:tag]; 6619 // Write the size of the message. 6620 size_t msgSize = ComputeDictUInt64FieldSize([aKey unsignedLongLongValue], kMapKeyFieldNumber, keyDataType); 6621 msgSize += ComputeDictFloatFieldSize([aValue floatValue], kMapValueFieldNumber, valueDataType); 6622 [outputStream writeInt32NoTag:(int32_t)msgSize]; 6623 // Write the fields. 6624 WriteDictUInt64Field(outputStream, [aKey unsignedLongLongValue], kMapKeyFieldNumber, keyDataType); 6625 WriteDictFloatField(outputStream, [aValue floatValue], kMapValueFieldNumber, valueDataType); 6626 }]; 6627 } 6628 6629 - (void)setGPBGenericValue:(GPBGenericValue *)value 6630 forGPBGenericValueKey:(GPBGenericValue *)key { 6631 [_dictionary setObject:@(value->valueFloat) forKey:@(key->valueUInt64)]; 6632 } 6633 6634 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 6635 [self enumerateKeysAndValuesUsingBlock:^(uint64_t key, float value, BOOL *stop) { 6636 #pragma unused(stop) 6637 block([NSString stringWithFormat:@"%llu", key], [NSString stringWithFormat:@"%.*g", FLT_DIG, value]); 6638 }]; 6639 } 6640 6641 - (BOOL)valueForKey:(uint64_t)key value:(float *)value { 6642 NSNumber *wrapped = [_dictionary objectForKey:@(key)]; 6643 if (wrapped && value) { 6644 *value = [wrapped floatValue]; 6645 } 6646 return (wrapped != NULL); 6647 } 6648 6649 - (void)addEntriesFromDictionary:(GPBUInt64FloatDictionary *)otherDictionary { 6650 if (otherDictionary) { 6651 [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 6652 if (_autocreator) { 6653 GPBAutocreatedDictionaryModified(_autocreator, self); 6654 } 6655 } 6656 } 6657 6658 - (void)setValue:(float)value forKey:(uint64_t)key { 6659 [_dictionary setObject:@(value) forKey:@(key)]; 6660 if (_autocreator) { 6661 GPBAutocreatedDictionaryModified(_autocreator, self); 6662 } 6663 } 6664 6665 - (void)removeValueForKey:(uint64_t)aKey { 6666 [_dictionary removeObjectForKey:@(aKey)]; 6667 } 6668 6669 - (void)removeAll { 6670 [_dictionary removeAllObjects]; 6671 } 6672 6673 @end 6674 6675 #pragma mark - UInt64 -> Double 6676 6677 @implementation GPBUInt64DoubleDictionary { 6678 @package 6679 NSMutableDictionary *_dictionary; 6680 } 6681 6682 + (instancetype)dictionary { 6683 return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; 6684 } 6685 6686 + (instancetype)dictionaryWithValue:(double)value 6687 forKey:(uint64_t)key { 6688 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 6689 // on to get the type correct. 6690 return [[(GPBUInt64DoubleDictionary*)[self alloc] initWithValues:&value 6691 forKeys:&key 6692 count:1] autorelease]; 6693 } 6694 6695 + (instancetype)dictionaryWithValues:(const double [])values 6696 forKeys:(const uint64_t [])keys 6697 count:(NSUInteger)count { 6698 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 6699 // on to get the type correct. 6700 return [[(GPBUInt64DoubleDictionary*)[self alloc] initWithValues:values 6701 forKeys:keys 6702 count:count] autorelease]; 6703 } 6704 6705 + (instancetype)dictionaryWithDictionary:(GPBUInt64DoubleDictionary *)dictionary { 6706 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 6707 // on to get the type correct. 6708 return [[(GPBUInt64DoubleDictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 6709 } 6710 6711 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 6712 return [[[self alloc] initWithCapacity:numItems] autorelease]; 6713 } 6714 6715 - (instancetype)init { 6716 return [self initWithValues:NULL forKeys:NULL count:0]; 6717 } 6718 6719 - (instancetype)initWithValues:(const double [])values 6720 forKeys:(const uint64_t [])keys 6721 count:(NSUInteger)count { 6722 self = [super init]; 6723 if (self) { 6724 _dictionary = [[NSMutableDictionary alloc] init]; 6725 if (count && values && keys) { 6726 for (NSUInteger i = 0; i < count; ++i) { 6727 [_dictionary setObject:@(values[i]) forKey:@(keys[i])]; 6728 } 6729 } 6730 } 6731 return self; 6732 } 6733 6734 - (instancetype)initWithDictionary:(GPBUInt64DoubleDictionary *)dictionary { 6735 self = [self initWithValues:NULL forKeys:NULL count:0]; 6736 if (self) { 6737 if (dictionary) { 6738 [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 6739 } 6740 } 6741 return self; 6742 } 6743 6744 - (instancetype)initWithCapacity:(NSUInteger)numItems { 6745 #pragma unused(numItems) 6746 return [self initWithValues:NULL forKeys:NULL count:0]; 6747 } 6748 6749 - (void)dealloc { 6750 NSAssert(!_autocreator, 6751 @"%@: Autocreator must be cleared before release, autocreator: %@", 6752 [self class], _autocreator); 6753 [_dictionary release]; 6754 [super dealloc]; 6755 } 6756 6757 - (instancetype)copyWithZone:(NSZone *)zone { 6758 return [[GPBUInt64DoubleDictionary allocWithZone:zone] initWithDictionary:self]; 6759 } 6760 6761 - (BOOL)isEqual:(GPBUInt64DoubleDictionary *)other { 6762 if (self == other) { 6763 return YES; 6764 } 6765 if (![other isKindOfClass:[GPBUInt64DoubleDictionary class]]) { 6766 return NO; 6767 } 6768 return [_dictionary isEqual:other->_dictionary]; 6769 } 6770 6771 - (NSUInteger)hash { 6772 return _dictionary.count; 6773 } 6774 6775 - (NSString *)description { 6776 return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 6777 } 6778 6779 - (NSUInteger)count { 6780 return _dictionary.count; 6781 } 6782 6783 - (void)enumerateKeysAndValuesUsingBlock: 6784 (void (^)(uint64_t key, double value, BOOL *stop))block { 6785 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 6786 NSNumber *aValue, 6787 BOOL *stop) { 6788 block([aKey unsignedLongLongValue], [aValue doubleValue], stop); 6789 }]; 6790 } 6791 6792 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 6793 NSUInteger count = _dictionary.count; 6794 if (count == 0) { 6795 return 0; 6796 } 6797 6798 GPBDataType valueDataType = GPBGetFieldDataType(field); 6799 GPBDataType keyDataType = field.mapKeyDataType; 6800 __block size_t result = 0; 6801 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 6802 NSNumber *aValue, 6803 BOOL *stop) { 6804 #pragma unused(stop) 6805 size_t msgSize = ComputeDictUInt64FieldSize([aKey unsignedLongLongValue], kMapKeyFieldNumber, keyDataType); 6806 msgSize += ComputeDictDoubleFieldSize([aValue doubleValue], kMapValueFieldNumber, valueDataType); 6807 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 6808 }]; 6809 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 6810 result += tagSize * count; 6811 return result; 6812 } 6813 6814 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 6815 asField:(GPBFieldDescriptor *)field { 6816 GPBDataType valueDataType = GPBGetFieldDataType(field); 6817 GPBDataType keyDataType = field.mapKeyDataType; 6818 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 6819 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 6820 NSNumber *aValue, 6821 BOOL *stop) { 6822 #pragma unused(stop) 6823 // Write the tag. 6824 [outputStream writeInt32NoTag:tag]; 6825 // Write the size of the message. 6826 size_t msgSize = ComputeDictUInt64FieldSize([aKey unsignedLongLongValue], kMapKeyFieldNumber, keyDataType); 6827 msgSize += ComputeDictDoubleFieldSize([aValue doubleValue], kMapValueFieldNumber, valueDataType); 6828 [outputStream writeInt32NoTag:(int32_t)msgSize]; 6829 // Write the fields. 6830 WriteDictUInt64Field(outputStream, [aKey unsignedLongLongValue], kMapKeyFieldNumber, keyDataType); 6831 WriteDictDoubleField(outputStream, [aValue doubleValue], kMapValueFieldNumber, valueDataType); 6832 }]; 6833 } 6834 6835 - (void)setGPBGenericValue:(GPBGenericValue *)value 6836 forGPBGenericValueKey:(GPBGenericValue *)key { 6837 [_dictionary setObject:@(value->valueDouble) forKey:@(key->valueUInt64)]; 6838 } 6839 6840 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 6841 [self enumerateKeysAndValuesUsingBlock:^(uint64_t key, double value, BOOL *stop) { 6842 #pragma unused(stop) 6843 block([NSString stringWithFormat:@"%llu", key], [NSString stringWithFormat:@"%.*lg", DBL_DIG, value]); 6844 }]; 6845 } 6846 6847 - (BOOL)valueForKey:(uint64_t)key value:(double *)value { 6848 NSNumber *wrapped = [_dictionary objectForKey:@(key)]; 6849 if (wrapped && value) { 6850 *value = [wrapped doubleValue]; 6851 } 6852 return (wrapped != NULL); 6853 } 6854 6855 - (void)addEntriesFromDictionary:(GPBUInt64DoubleDictionary *)otherDictionary { 6856 if (otherDictionary) { 6857 [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 6858 if (_autocreator) { 6859 GPBAutocreatedDictionaryModified(_autocreator, self); 6860 } 6861 } 6862 } 6863 6864 - (void)setValue:(double)value forKey:(uint64_t)key { 6865 [_dictionary setObject:@(value) forKey:@(key)]; 6866 if (_autocreator) { 6867 GPBAutocreatedDictionaryModified(_autocreator, self); 6868 } 6869 } 6870 6871 - (void)removeValueForKey:(uint64_t)aKey { 6872 [_dictionary removeObjectForKey:@(aKey)]; 6873 } 6874 6875 - (void)removeAll { 6876 [_dictionary removeAllObjects]; 6877 } 6878 6879 @end 6880 6881 #pragma mark - UInt64 -> Enum 6882 6883 @implementation GPBUInt64EnumDictionary { 6884 @package 6885 NSMutableDictionary *_dictionary; 6886 GPBEnumValidationFunc _validationFunc; 6887 } 6888 6889 @synthesize validationFunc = _validationFunc; 6890 6891 + (instancetype)dictionary { 6892 return [[[self alloc] initWithValidationFunction:NULL 6893 rawValues:NULL 6894 forKeys:NULL 6895 count:0] autorelease]; 6896 } 6897 6898 + (instancetype)dictionaryWithValidationFunction:(GPBEnumValidationFunc)func { 6899 return [[[self alloc] initWithValidationFunction:func 6900 rawValues:NULL 6901 forKeys:NULL 6902 count:0] autorelease]; 6903 } 6904 6905 + (instancetype)dictionaryWithValidationFunction:(GPBEnumValidationFunc)func 6906 rawValue:(int32_t)rawValue 6907 forKey:(uint64_t)key { 6908 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 6909 // on to get the type correct. 6910 return [[(GPBUInt64EnumDictionary*)[self alloc] initWithValidationFunction:func 6911 rawValues:&rawValue 6912 forKeys:&key 6913 count:1] autorelease]; 6914 } 6915 6916 + (instancetype)dictionaryWithValidationFunction:(GPBEnumValidationFunc)func 6917 rawValues:(const int32_t [])rawValues 6918 forKeys:(const uint64_t [])keys 6919 count:(NSUInteger)count { 6920 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 6921 // on to get the type correct. 6922 return [[(GPBUInt64EnumDictionary*)[self alloc] initWithValidationFunction:func 6923 rawValues:rawValues 6924 forKeys:keys 6925 count:count] autorelease]; 6926 } 6927 6928 + (instancetype)dictionaryWithDictionary:(GPBUInt64EnumDictionary *)dictionary { 6929 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 6930 // on to get the type correct. 6931 return [[(GPBUInt64EnumDictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 6932 } 6933 6934 + (instancetype)dictionaryWithValidationFunction:(GPBEnumValidationFunc)func 6935 capacity:(NSUInteger)numItems { 6936 return [[[self alloc] initWithValidationFunction:func capacity:numItems] autorelease]; 6937 } 6938 6939 - (instancetype)init { 6940 return [self initWithValidationFunction:NULL rawValues:NULL forKeys:NULL count:0]; 6941 } 6942 6943 - (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func { 6944 return [self initWithValidationFunction:func rawValues:NULL forKeys:NULL count:0]; 6945 } 6946 6947 - (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func 6948 rawValues:(const int32_t [])rawValues 6949 forKeys:(const uint64_t [])keys 6950 count:(NSUInteger)count { 6951 self = [super init]; 6952 if (self) { 6953 _dictionary = [[NSMutableDictionary alloc] init]; 6954 _validationFunc = (func != NULL ? func : DictDefault_IsValidValue); 6955 if (count && rawValues && keys) { 6956 for (NSUInteger i = 0; i < count; ++i) { 6957 [_dictionary setObject:@(rawValues[i]) forKey:@(keys[i])]; 6958 } 6959 } 6960 } 6961 return self; 6962 } 6963 6964 - (instancetype)initWithDictionary:(GPBUInt64EnumDictionary *)dictionary { 6965 self = [self initWithValidationFunction:dictionary.validationFunc 6966 rawValues:NULL 6967 forKeys:NULL 6968 count:0]; 6969 if (self) { 6970 if (dictionary) { 6971 [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 6972 } 6973 } 6974 return self; 6975 } 6976 6977 - (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func 6978 capacity:(NSUInteger)numItems { 6979 #pragma unused(numItems) 6980 return [self initWithValidationFunction:func rawValues:NULL forKeys:NULL count:0]; 6981 } 6982 6983 - (void)dealloc { 6984 NSAssert(!_autocreator, 6985 @"%@: Autocreator must be cleared before release, autocreator: %@", 6986 [self class], _autocreator); 6987 [_dictionary release]; 6988 [super dealloc]; 6989 } 6990 6991 - (instancetype)copyWithZone:(NSZone *)zone { 6992 return [[GPBUInt64EnumDictionary allocWithZone:zone] initWithDictionary:self]; 6993 } 6994 6995 - (BOOL)isEqual:(GPBUInt64EnumDictionary *)other { 6996 if (self == other) { 6997 return YES; 6998 } 6999 if (![other isKindOfClass:[GPBUInt64EnumDictionary class]]) { 7000 return NO; 7001 } 7002 return [_dictionary isEqual:other->_dictionary]; 7003 } 7004 7005 - (NSUInteger)hash { 7006 return _dictionary.count; 7007 } 7008 7009 - (NSString *)description { 7010 return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 7011 } 7012 7013 - (NSUInteger)count { 7014 return _dictionary.count; 7015 } 7016 7017 - (void)enumerateKeysAndRawValuesUsingBlock: 7018 (void (^)(uint64_t key, int32_t value, BOOL *stop))block { 7019 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 7020 NSNumber *aValue, 7021 BOOL *stop) { 7022 block([aKey unsignedLongLongValue], [aValue intValue], stop); 7023 }]; 7024 } 7025 7026 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 7027 NSUInteger count = _dictionary.count; 7028 if (count == 0) { 7029 return 0; 7030 } 7031 7032 GPBDataType valueDataType = GPBGetFieldDataType(field); 7033 GPBDataType keyDataType = field.mapKeyDataType; 7034 __block size_t result = 0; 7035 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 7036 NSNumber *aValue, 7037 BOOL *stop) { 7038 #pragma unused(stop) 7039 size_t msgSize = ComputeDictUInt64FieldSize([aKey unsignedLongLongValue], kMapKeyFieldNumber, keyDataType); 7040 msgSize += ComputeDictEnumFieldSize([aValue intValue], kMapValueFieldNumber, valueDataType); 7041 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 7042 }]; 7043 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 7044 result += tagSize * count; 7045 return result; 7046 } 7047 7048 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 7049 asField:(GPBFieldDescriptor *)field { 7050 GPBDataType valueDataType = GPBGetFieldDataType(field); 7051 GPBDataType keyDataType = field.mapKeyDataType; 7052 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 7053 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 7054 NSNumber *aValue, 7055 BOOL *stop) { 7056 #pragma unused(stop) 7057 // Write the tag. 7058 [outputStream writeInt32NoTag:tag]; 7059 // Write the size of the message. 7060 size_t msgSize = ComputeDictUInt64FieldSize([aKey unsignedLongLongValue], kMapKeyFieldNumber, keyDataType); 7061 msgSize += ComputeDictEnumFieldSize([aValue intValue], kMapValueFieldNumber, valueDataType); 7062 [outputStream writeInt32NoTag:(int32_t)msgSize]; 7063 // Write the fields. 7064 WriteDictUInt64Field(outputStream, [aKey unsignedLongLongValue], kMapKeyFieldNumber, keyDataType); 7065 WriteDictEnumField(outputStream, [aValue intValue], kMapValueFieldNumber, valueDataType); 7066 }]; 7067 } 7068 7069 - (NSData *)serializedDataForUnknownValue:(int32_t)value 7070 forKey:(GPBGenericValue *)key 7071 keyDataType:(GPBDataType)keyDataType { 7072 size_t msgSize = ComputeDictUInt64FieldSize(key->valueUInt64, kMapKeyFieldNumber, keyDataType); 7073 msgSize += ComputeDictEnumFieldSize(value, kMapValueFieldNumber, GPBDataTypeEnum); 7074 NSMutableData *data = [NSMutableData dataWithLength:msgSize]; 7075 GPBCodedOutputStream *outputStream = [[GPBCodedOutputStream alloc] initWithData:data]; 7076 WriteDictUInt64Field(outputStream, key->valueUInt64, kMapKeyFieldNumber, keyDataType); 7077 WriteDictEnumField(outputStream, value, kMapValueFieldNumber, GPBDataTypeEnum); 7078 [outputStream release]; 7079 return data; 7080 } 7081 - (void)setGPBGenericValue:(GPBGenericValue *)value 7082 forGPBGenericValueKey:(GPBGenericValue *)key { 7083 [_dictionary setObject:@(value->valueEnum) forKey:@(key->valueUInt64)]; 7084 } 7085 7086 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 7087 [self enumerateKeysAndRawValuesUsingBlock:^(uint64_t key, int32_t value, BOOL *stop) { 7088 #pragma unused(stop) 7089 block([NSString stringWithFormat:@"%llu", key], @(value)); 7090 }]; 7091 } 7092 7093 - (BOOL)valueForKey:(uint64_t)key value:(int32_t *)value { 7094 NSNumber *wrapped = [_dictionary objectForKey:@(key)]; 7095 if (wrapped && value) { 7096 int32_t result = [wrapped intValue]; 7097 if (!_validationFunc(result)) { 7098 result = kGPBUnrecognizedEnumeratorValue; 7099 } 7100 *value = result; 7101 } 7102 return (wrapped != NULL); 7103 } 7104 7105 - (BOOL)valueForKey:(uint64_t)key rawValue:(int32_t *)rawValue { 7106 NSNumber *wrapped = [_dictionary objectForKey:@(key)]; 7107 if (wrapped && rawValue) { 7108 *rawValue = [wrapped intValue]; 7109 } 7110 return (wrapped != NULL); 7111 } 7112 7113 - (void)enumerateKeysAndValuesUsingBlock: 7114 (void (^)(uint64_t key, int32_t value, BOOL *stop))block { 7115 GPBEnumValidationFunc func = _validationFunc; 7116 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 7117 NSNumber *aValue, 7118 BOOL *stop) { 7119 int32_t unwrapped = [aValue intValue]; 7120 if (!func(unwrapped)) { 7121 unwrapped = kGPBUnrecognizedEnumeratorValue; 7122 } 7123 block([aKey unsignedLongLongValue], unwrapped, stop); 7124 }]; 7125 } 7126 7127 - (void)addRawEntriesFromDictionary:(GPBUInt64EnumDictionary *)otherDictionary { 7128 if (otherDictionary) { 7129 [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 7130 if (_autocreator) { 7131 GPBAutocreatedDictionaryModified(_autocreator, self); 7132 } 7133 } 7134 } 7135 7136 - (void)setRawValue:(int32_t)value forKey:(uint64_t)key { 7137 [_dictionary setObject:@(value) forKey:@(key)]; 7138 if (_autocreator) { 7139 GPBAutocreatedDictionaryModified(_autocreator, self); 7140 } 7141 } 7142 7143 - (void)removeValueForKey:(uint64_t)aKey { 7144 [_dictionary removeObjectForKey:@(aKey)]; 7145 } 7146 7147 - (void)removeAll { 7148 [_dictionary removeAllObjects]; 7149 } 7150 7151 - (void)setValue:(int32_t)value forKey:(uint64_t)key { 7152 if (!_validationFunc(value)) { 7153 [NSException raise:NSInvalidArgumentException 7154 format:@"GPBUInt64EnumDictionary: Attempt to set an unknown enum value (%d)", 7155 value]; 7156 } 7157 7158 [_dictionary setObject:@(value) forKey:@(key)]; 7159 if (_autocreator) { 7160 GPBAutocreatedDictionaryModified(_autocreator, self); 7161 } 7162 } 7163 7164 @end 7165 7166 #pragma mark - UInt64 -> Object 7167 7168 @implementation GPBUInt64ObjectDictionary { 7169 @package 7170 NSMutableDictionary *_dictionary; 7171 } 7172 7173 + (instancetype)dictionary { 7174 return [[[self alloc] initWithObjects:NULL forKeys:NULL count:0] autorelease]; 7175 } 7176 7177 + (instancetype)dictionaryWithObject:(id)object 7178 forKey:(uint64_t)key { 7179 // Cast is needed so the compiler knows what class we are invoking initWithObjects:forKeys:count: 7180 // on to get the type correct. 7181 return [[(GPBUInt64ObjectDictionary*)[self alloc] initWithObjects:&object 7182 forKeys:&key 7183 count:1] autorelease]; 7184 } 7185 7186 + (instancetype)dictionaryWithObjects:(const id [])objects 7187 forKeys:(const uint64_t [])keys 7188 count:(NSUInteger)count { 7189 // Cast is needed so the compiler knows what class we are invoking initWithObjects:forKeys:count: 7190 // on to get the type correct. 7191 return [[(GPBUInt64ObjectDictionary*)[self alloc] initWithObjects:objects 7192 forKeys:keys 7193 count:count] autorelease]; 7194 } 7195 7196 + (instancetype)dictionaryWithDictionary:(GPBUInt64ObjectDictionary *)dictionary { 7197 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 7198 // on to get the type correct. 7199 return [[(GPBUInt64ObjectDictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 7200 } 7201 7202 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 7203 return [[[self alloc] initWithCapacity:numItems] autorelease]; 7204 } 7205 7206 - (instancetype)init { 7207 return [self initWithObjects:NULL forKeys:NULL count:0]; 7208 } 7209 7210 - (instancetype)initWithObjects:(const id [])objects 7211 forKeys:(const uint64_t [])keys 7212 count:(NSUInteger)count { 7213 self = [super init]; 7214 if (self) { 7215 _dictionary = [[NSMutableDictionary alloc] init]; 7216 if (count && objects && keys) { 7217 for (NSUInteger i = 0; i < count; ++i) { 7218 if (!objects[i]) { 7219 [NSException raise:NSInvalidArgumentException 7220 format:@"Attempting to add nil object to a Dictionary"]; 7221 } 7222 [_dictionary setObject:objects[i] forKey:@(keys[i])]; 7223 } 7224 } 7225 } 7226 return self; 7227 } 7228 7229 - (instancetype)initWithDictionary:(GPBUInt64ObjectDictionary *)dictionary { 7230 self = [self initWithObjects:NULL forKeys:NULL count:0]; 7231 if (self) { 7232 if (dictionary) { 7233 [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 7234 } 7235 } 7236 return self; 7237 } 7238 7239 - (instancetype)initWithCapacity:(NSUInteger)numItems { 7240 #pragma unused(numItems) 7241 return [self initWithObjects:NULL forKeys:NULL count:0]; 7242 } 7243 7244 - (void)dealloc { 7245 NSAssert(!_autocreator, 7246 @"%@: Autocreator must be cleared before release, autocreator: %@", 7247 [self class], _autocreator); 7248 [_dictionary release]; 7249 [super dealloc]; 7250 } 7251 7252 - (instancetype)copyWithZone:(NSZone *)zone { 7253 return [[GPBUInt64ObjectDictionary allocWithZone:zone] initWithDictionary:self]; 7254 } 7255 7256 - (BOOL)isEqual:(GPBUInt64ObjectDictionary *)other { 7257 if (self == other) { 7258 return YES; 7259 } 7260 if (![other isKindOfClass:[GPBUInt64ObjectDictionary class]]) { 7261 return NO; 7262 } 7263 return [_dictionary isEqual:other->_dictionary]; 7264 } 7265 7266 - (NSUInteger)hash { 7267 return _dictionary.count; 7268 } 7269 7270 - (NSString *)description { 7271 return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 7272 } 7273 7274 - (NSUInteger)count { 7275 return _dictionary.count; 7276 } 7277 7278 - (void)enumerateKeysAndObjectsUsingBlock: 7279 (void (^)(uint64_t key, id object, BOOL *stop))block { 7280 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 7281 id aObject, 7282 BOOL *stop) { 7283 block([aKey unsignedLongLongValue], aObject, stop); 7284 }]; 7285 } 7286 7287 - (BOOL)isInitialized { 7288 for (GPBMessage *msg in [_dictionary objectEnumerator]) { 7289 if (!msg.initialized) { 7290 return NO; 7291 } 7292 } 7293 return YES; 7294 } 7295 7296 - (instancetype)deepCopyWithZone:(NSZone *)zone { 7297 GPBUInt64ObjectDictionary *newDict = 7298 [[GPBUInt64ObjectDictionary alloc] init]; 7299 [_dictionary enumerateKeysAndObjectsUsingBlock:^(id aKey, 7300 GPBMessage *msg, 7301 BOOL *stop) { 7302 #pragma unused(stop) 7303 GPBMessage *copiedMsg = [msg copyWithZone:zone]; 7304 [newDict->_dictionary setObject:copiedMsg forKey:aKey]; 7305 [copiedMsg release]; 7306 }]; 7307 return newDict; 7308 } 7309 7310 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 7311 NSUInteger count = _dictionary.count; 7312 if (count == 0) { 7313 return 0; 7314 } 7315 7316 GPBDataType valueDataType = GPBGetFieldDataType(field); 7317 GPBDataType keyDataType = field.mapKeyDataType; 7318 __block size_t result = 0; 7319 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 7320 id aObject, 7321 BOOL *stop) { 7322 #pragma unused(stop) 7323 size_t msgSize = ComputeDictUInt64FieldSize([aKey unsignedLongLongValue], kMapKeyFieldNumber, keyDataType); 7324 msgSize += ComputeDictObjectFieldSize(aObject, kMapValueFieldNumber, valueDataType); 7325 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 7326 }]; 7327 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 7328 result += tagSize * count; 7329 return result; 7330 } 7331 7332 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 7333 asField:(GPBFieldDescriptor *)field { 7334 GPBDataType valueDataType = GPBGetFieldDataType(field); 7335 GPBDataType keyDataType = field.mapKeyDataType; 7336 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 7337 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 7338 id aObject, 7339 BOOL *stop) { 7340 #pragma unused(stop) 7341 // Write the tag. 7342 [outputStream writeInt32NoTag:tag]; 7343 // Write the size of the message. 7344 size_t msgSize = ComputeDictUInt64FieldSize([aKey unsignedLongLongValue], kMapKeyFieldNumber, keyDataType); 7345 msgSize += ComputeDictObjectFieldSize(aObject, kMapValueFieldNumber, valueDataType); 7346 [outputStream writeInt32NoTag:(int32_t)msgSize]; 7347 // Write the fields. 7348 WriteDictUInt64Field(outputStream, [aKey unsignedLongLongValue], kMapKeyFieldNumber, keyDataType); 7349 WriteDictObjectField(outputStream, aObject, kMapValueFieldNumber, valueDataType); 7350 }]; 7351 } 7352 7353 - (void)setGPBGenericValue:(GPBGenericValue *)value 7354 forGPBGenericValueKey:(GPBGenericValue *)key { 7355 [_dictionary setObject:value->valueString forKey:@(key->valueUInt64)]; 7356 } 7357 7358 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 7359 [self enumerateKeysAndObjectsUsingBlock:^(uint64_t key, id object, BOOL *stop) { 7360 #pragma unused(stop) 7361 block([NSString stringWithFormat:@"%llu", key], object); 7362 }]; 7363 } 7364 7365 - (id)objectForKey:(uint64_t)key { 7366 id result = [_dictionary objectForKey:@(key)]; 7367 return result; 7368 } 7369 7370 - (void)addEntriesFromDictionary:(GPBUInt64ObjectDictionary *)otherDictionary { 7371 if (otherDictionary) { 7372 [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 7373 if (_autocreator) { 7374 GPBAutocreatedDictionaryModified(_autocreator, self); 7375 } 7376 } 7377 } 7378 7379 - (void)setObject:(id)object forKey:(uint64_t)key { 7380 if (!object) { 7381 [NSException raise:NSInvalidArgumentException 7382 format:@"Attempting to add nil object to a Dictionary"]; 7383 } 7384 [_dictionary setObject:object forKey:@(key)]; 7385 if (_autocreator) { 7386 GPBAutocreatedDictionaryModified(_autocreator, self); 7387 } 7388 } 7389 7390 - (void)removeObjectForKey:(uint64_t)aKey { 7391 [_dictionary removeObjectForKey:@(aKey)]; 7392 } 7393 7394 - (void)removeAll { 7395 [_dictionary removeAllObjects]; 7396 } 7397 7398 @end 7399 7400 //%PDDM-EXPAND DICTIONARY_IMPL_FOR_POD_KEY(Int64, int64_t) 7401 // This block of code is generated, do not edit it directly. 7402 7403 #pragma mark - Int64 -> UInt32 7404 7405 @implementation GPBInt64UInt32Dictionary { 7406 @package 7407 NSMutableDictionary *_dictionary; 7408 } 7409 7410 + (instancetype)dictionary { 7411 return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; 7412 } 7413 7414 + (instancetype)dictionaryWithValue:(uint32_t)value 7415 forKey:(int64_t)key { 7416 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 7417 // on to get the type correct. 7418 return [[(GPBInt64UInt32Dictionary*)[self alloc] initWithValues:&value 7419 forKeys:&key 7420 count:1] autorelease]; 7421 } 7422 7423 + (instancetype)dictionaryWithValues:(const uint32_t [])values 7424 forKeys:(const int64_t [])keys 7425 count:(NSUInteger)count { 7426 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 7427 // on to get the type correct. 7428 return [[(GPBInt64UInt32Dictionary*)[self alloc] initWithValues:values 7429 forKeys:keys 7430 count:count] autorelease]; 7431 } 7432 7433 + (instancetype)dictionaryWithDictionary:(GPBInt64UInt32Dictionary *)dictionary { 7434 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 7435 // on to get the type correct. 7436 return [[(GPBInt64UInt32Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 7437 } 7438 7439 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 7440 return [[[self alloc] initWithCapacity:numItems] autorelease]; 7441 } 7442 7443 - (instancetype)init { 7444 return [self initWithValues:NULL forKeys:NULL count:0]; 7445 } 7446 7447 - (instancetype)initWithValues:(const uint32_t [])values 7448 forKeys:(const int64_t [])keys 7449 count:(NSUInteger)count { 7450 self = [super init]; 7451 if (self) { 7452 _dictionary = [[NSMutableDictionary alloc] init]; 7453 if (count && values && keys) { 7454 for (NSUInteger i = 0; i < count; ++i) { 7455 [_dictionary setObject:@(values[i]) forKey:@(keys[i])]; 7456 } 7457 } 7458 } 7459 return self; 7460 } 7461 7462 - (instancetype)initWithDictionary:(GPBInt64UInt32Dictionary *)dictionary { 7463 self = [self initWithValues:NULL forKeys:NULL count:0]; 7464 if (self) { 7465 if (dictionary) { 7466 [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 7467 } 7468 } 7469 return self; 7470 } 7471 7472 - (instancetype)initWithCapacity:(NSUInteger)numItems { 7473 #pragma unused(numItems) 7474 return [self initWithValues:NULL forKeys:NULL count:0]; 7475 } 7476 7477 - (void)dealloc { 7478 NSAssert(!_autocreator, 7479 @"%@: Autocreator must be cleared before release, autocreator: %@", 7480 [self class], _autocreator); 7481 [_dictionary release]; 7482 [super dealloc]; 7483 } 7484 7485 - (instancetype)copyWithZone:(NSZone *)zone { 7486 return [[GPBInt64UInt32Dictionary allocWithZone:zone] initWithDictionary:self]; 7487 } 7488 7489 - (BOOL)isEqual:(GPBInt64UInt32Dictionary *)other { 7490 if (self == other) { 7491 return YES; 7492 } 7493 if (![other isKindOfClass:[GPBInt64UInt32Dictionary class]]) { 7494 return NO; 7495 } 7496 return [_dictionary isEqual:other->_dictionary]; 7497 } 7498 7499 - (NSUInteger)hash { 7500 return _dictionary.count; 7501 } 7502 7503 - (NSString *)description { 7504 return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 7505 } 7506 7507 - (NSUInteger)count { 7508 return _dictionary.count; 7509 } 7510 7511 - (void)enumerateKeysAndValuesUsingBlock: 7512 (void (^)(int64_t key, uint32_t value, BOOL *stop))block { 7513 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 7514 NSNumber *aValue, 7515 BOOL *stop) { 7516 block([aKey longLongValue], [aValue unsignedIntValue], stop); 7517 }]; 7518 } 7519 7520 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 7521 NSUInteger count = _dictionary.count; 7522 if (count == 0) { 7523 return 0; 7524 } 7525 7526 GPBDataType valueDataType = GPBGetFieldDataType(field); 7527 GPBDataType keyDataType = field.mapKeyDataType; 7528 __block size_t result = 0; 7529 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 7530 NSNumber *aValue, 7531 BOOL *stop) { 7532 #pragma unused(stop) 7533 size_t msgSize = ComputeDictInt64FieldSize([aKey longLongValue], kMapKeyFieldNumber, keyDataType); 7534 msgSize += ComputeDictUInt32FieldSize([aValue unsignedIntValue], kMapValueFieldNumber, valueDataType); 7535 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 7536 }]; 7537 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 7538 result += tagSize * count; 7539 return result; 7540 } 7541 7542 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 7543 asField:(GPBFieldDescriptor *)field { 7544 GPBDataType valueDataType = GPBGetFieldDataType(field); 7545 GPBDataType keyDataType = field.mapKeyDataType; 7546 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 7547 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 7548 NSNumber *aValue, 7549 BOOL *stop) { 7550 #pragma unused(stop) 7551 // Write the tag. 7552 [outputStream writeInt32NoTag:tag]; 7553 // Write the size of the message. 7554 size_t msgSize = ComputeDictInt64FieldSize([aKey longLongValue], kMapKeyFieldNumber, keyDataType); 7555 msgSize += ComputeDictUInt32FieldSize([aValue unsignedIntValue], kMapValueFieldNumber, valueDataType); 7556 [outputStream writeInt32NoTag:(int32_t)msgSize]; 7557 // Write the fields. 7558 WriteDictInt64Field(outputStream, [aKey longLongValue], kMapKeyFieldNumber, keyDataType); 7559 WriteDictUInt32Field(outputStream, [aValue unsignedIntValue], kMapValueFieldNumber, valueDataType); 7560 }]; 7561 } 7562 7563 - (void)setGPBGenericValue:(GPBGenericValue *)value 7564 forGPBGenericValueKey:(GPBGenericValue *)key { 7565 [_dictionary setObject:@(value->valueUInt32) forKey:@(key->valueInt64)]; 7566 } 7567 7568 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 7569 [self enumerateKeysAndValuesUsingBlock:^(int64_t key, uint32_t value, BOOL *stop) { 7570 #pragma unused(stop) 7571 block([NSString stringWithFormat:@"%lld", key], [NSString stringWithFormat:@"%u", value]); 7572 }]; 7573 } 7574 7575 - (BOOL)valueForKey:(int64_t)key value:(uint32_t *)value { 7576 NSNumber *wrapped = [_dictionary objectForKey:@(key)]; 7577 if (wrapped && value) { 7578 *value = [wrapped unsignedIntValue]; 7579 } 7580 return (wrapped != NULL); 7581 } 7582 7583 - (void)addEntriesFromDictionary:(GPBInt64UInt32Dictionary *)otherDictionary { 7584 if (otherDictionary) { 7585 [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 7586 if (_autocreator) { 7587 GPBAutocreatedDictionaryModified(_autocreator, self); 7588 } 7589 } 7590 } 7591 7592 - (void)setValue:(uint32_t)value forKey:(int64_t)key { 7593 [_dictionary setObject:@(value) forKey:@(key)]; 7594 if (_autocreator) { 7595 GPBAutocreatedDictionaryModified(_autocreator, self); 7596 } 7597 } 7598 7599 - (void)removeValueForKey:(int64_t)aKey { 7600 [_dictionary removeObjectForKey:@(aKey)]; 7601 } 7602 7603 - (void)removeAll { 7604 [_dictionary removeAllObjects]; 7605 } 7606 7607 @end 7608 7609 #pragma mark - Int64 -> Int32 7610 7611 @implementation GPBInt64Int32Dictionary { 7612 @package 7613 NSMutableDictionary *_dictionary; 7614 } 7615 7616 + (instancetype)dictionary { 7617 return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; 7618 } 7619 7620 + (instancetype)dictionaryWithValue:(int32_t)value 7621 forKey:(int64_t)key { 7622 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 7623 // on to get the type correct. 7624 return [[(GPBInt64Int32Dictionary*)[self alloc] initWithValues:&value 7625 forKeys:&key 7626 count:1] autorelease]; 7627 } 7628 7629 + (instancetype)dictionaryWithValues:(const int32_t [])values 7630 forKeys:(const int64_t [])keys 7631 count:(NSUInteger)count { 7632 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 7633 // on to get the type correct. 7634 return [[(GPBInt64Int32Dictionary*)[self alloc] initWithValues:values 7635 forKeys:keys 7636 count:count] autorelease]; 7637 } 7638 7639 + (instancetype)dictionaryWithDictionary:(GPBInt64Int32Dictionary *)dictionary { 7640 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 7641 // on to get the type correct. 7642 return [[(GPBInt64Int32Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 7643 } 7644 7645 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 7646 return [[[self alloc] initWithCapacity:numItems] autorelease]; 7647 } 7648 7649 - (instancetype)init { 7650 return [self initWithValues:NULL forKeys:NULL count:0]; 7651 } 7652 7653 - (instancetype)initWithValues:(const int32_t [])values 7654 forKeys:(const int64_t [])keys 7655 count:(NSUInteger)count { 7656 self = [super init]; 7657 if (self) { 7658 _dictionary = [[NSMutableDictionary alloc] init]; 7659 if (count && values && keys) { 7660 for (NSUInteger i = 0; i < count; ++i) { 7661 [_dictionary setObject:@(values[i]) forKey:@(keys[i])]; 7662 } 7663 } 7664 } 7665 return self; 7666 } 7667 7668 - (instancetype)initWithDictionary:(GPBInt64Int32Dictionary *)dictionary { 7669 self = [self initWithValues:NULL forKeys:NULL count:0]; 7670 if (self) { 7671 if (dictionary) { 7672 [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 7673 } 7674 } 7675 return self; 7676 } 7677 7678 - (instancetype)initWithCapacity:(NSUInteger)numItems { 7679 #pragma unused(numItems) 7680 return [self initWithValues:NULL forKeys:NULL count:0]; 7681 } 7682 7683 - (void)dealloc { 7684 NSAssert(!_autocreator, 7685 @"%@: Autocreator must be cleared before release, autocreator: %@", 7686 [self class], _autocreator); 7687 [_dictionary release]; 7688 [super dealloc]; 7689 } 7690 7691 - (instancetype)copyWithZone:(NSZone *)zone { 7692 return [[GPBInt64Int32Dictionary allocWithZone:zone] initWithDictionary:self]; 7693 } 7694 7695 - (BOOL)isEqual:(GPBInt64Int32Dictionary *)other { 7696 if (self == other) { 7697 return YES; 7698 } 7699 if (![other isKindOfClass:[GPBInt64Int32Dictionary class]]) { 7700 return NO; 7701 } 7702 return [_dictionary isEqual:other->_dictionary]; 7703 } 7704 7705 - (NSUInteger)hash { 7706 return _dictionary.count; 7707 } 7708 7709 - (NSString *)description { 7710 return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 7711 } 7712 7713 - (NSUInteger)count { 7714 return _dictionary.count; 7715 } 7716 7717 - (void)enumerateKeysAndValuesUsingBlock: 7718 (void (^)(int64_t key, int32_t value, BOOL *stop))block { 7719 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 7720 NSNumber *aValue, 7721 BOOL *stop) { 7722 block([aKey longLongValue], [aValue intValue], stop); 7723 }]; 7724 } 7725 7726 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 7727 NSUInteger count = _dictionary.count; 7728 if (count == 0) { 7729 return 0; 7730 } 7731 7732 GPBDataType valueDataType = GPBGetFieldDataType(field); 7733 GPBDataType keyDataType = field.mapKeyDataType; 7734 __block size_t result = 0; 7735 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 7736 NSNumber *aValue, 7737 BOOL *stop) { 7738 #pragma unused(stop) 7739 size_t msgSize = ComputeDictInt64FieldSize([aKey longLongValue], kMapKeyFieldNumber, keyDataType); 7740 msgSize += ComputeDictInt32FieldSize([aValue intValue], kMapValueFieldNumber, valueDataType); 7741 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 7742 }]; 7743 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 7744 result += tagSize * count; 7745 return result; 7746 } 7747 7748 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 7749 asField:(GPBFieldDescriptor *)field { 7750 GPBDataType valueDataType = GPBGetFieldDataType(field); 7751 GPBDataType keyDataType = field.mapKeyDataType; 7752 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 7753 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 7754 NSNumber *aValue, 7755 BOOL *stop) { 7756 #pragma unused(stop) 7757 // Write the tag. 7758 [outputStream writeInt32NoTag:tag]; 7759 // Write the size of the message. 7760 size_t msgSize = ComputeDictInt64FieldSize([aKey longLongValue], kMapKeyFieldNumber, keyDataType); 7761 msgSize += ComputeDictInt32FieldSize([aValue intValue], kMapValueFieldNumber, valueDataType); 7762 [outputStream writeInt32NoTag:(int32_t)msgSize]; 7763 // Write the fields. 7764 WriteDictInt64Field(outputStream, [aKey longLongValue], kMapKeyFieldNumber, keyDataType); 7765 WriteDictInt32Field(outputStream, [aValue intValue], kMapValueFieldNumber, valueDataType); 7766 }]; 7767 } 7768 7769 - (void)setGPBGenericValue:(GPBGenericValue *)value 7770 forGPBGenericValueKey:(GPBGenericValue *)key { 7771 [_dictionary setObject:@(value->valueInt32) forKey:@(key->valueInt64)]; 7772 } 7773 7774 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 7775 [self enumerateKeysAndValuesUsingBlock:^(int64_t key, int32_t value, BOOL *stop) { 7776 #pragma unused(stop) 7777 block([NSString stringWithFormat:@"%lld", key], [NSString stringWithFormat:@"%d", value]); 7778 }]; 7779 } 7780 7781 - (BOOL)valueForKey:(int64_t)key value:(int32_t *)value { 7782 NSNumber *wrapped = [_dictionary objectForKey:@(key)]; 7783 if (wrapped && value) { 7784 *value = [wrapped intValue]; 7785 } 7786 return (wrapped != NULL); 7787 } 7788 7789 - (void)addEntriesFromDictionary:(GPBInt64Int32Dictionary *)otherDictionary { 7790 if (otherDictionary) { 7791 [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 7792 if (_autocreator) { 7793 GPBAutocreatedDictionaryModified(_autocreator, self); 7794 } 7795 } 7796 } 7797 7798 - (void)setValue:(int32_t)value forKey:(int64_t)key { 7799 [_dictionary setObject:@(value) forKey:@(key)]; 7800 if (_autocreator) { 7801 GPBAutocreatedDictionaryModified(_autocreator, self); 7802 } 7803 } 7804 7805 - (void)removeValueForKey:(int64_t)aKey { 7806 [_dictionary removeObjectForKey:@(aKey)]; 7807 } 7808 7809 - (void)removeAll { 7810 [_dictionary removeAllObjects]; 7811 } 7812 7813 @end 7814 7815 #pragma mark - Int64 -> UInt64 7816 7817 @implementation GPBInt64UInt64Dictionary { 7818 @package 7819 NSMutableDictionary *_dictionary; 7820 } 7821 7822 + (instancetype)dictionary { 7823 return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; 7824 } 7825 7826 + (instancetype)dictionaryWithValue:(uint64_t)value 7827 forKey:(int64_t)key { 7828 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 7829 // on to get the type correct. 7830 return [[(GPBInt64UInt64Dictionary*)[self alloc] initWithValues:&value 7831 forKeys:&key 7832 count:1] autorelease]; 7833 } 7834 7835 + (instancetype)dictionaryWithValues:(const uint64_t [])values 7836 forKeys:(const int64_t [])keys 7837 count:(NSUInteger)count { 7838 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 7839 // on to get the type correct. 7840 return [[(GPBInt64UInt64Dictionary*)[self alloc] initWithValues:values 7841 forKeys:keys 7842 count:count] autorelease]; 7843 } 7844 7845 + (instancetype)dictionaryWithDictionary:(GPBInt64UInt64Dictionary *)dictionary { 7846 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 7847 // on to get the type correct. 7848 return [[(GPBInt64UInt64Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 7849 } 7850 7851 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 7852 return [[[self alloc] initWithCapacity:numItems] autorelease]; 7853 } 7854 7855 - (instancetype)init { 7856 return [self initWithValues:NULL forKeys:NULL count:0]; 7857 } 7858 7859 - (instancetype)initWithValues:(const uint64_t [])values 7860 forKeys:(const int64_t [])keys 7861 count:(NSUInteger)count { 7862 self = [super init]; 7863 if (self) { 7864 _dictionary = [[NSMutableDictionary alloc] init]; 7865 if (count && values && keys) { 7866 for (NSUInteger i = 0; i < count; ++i) { 7867 [_dictionary setObject:@(values[i]) forKey:@(keys[i])]; 7868 } 7869 } 7870 } 7871 return self; 7872 } 7873 7874 - (instancetype)initWithDictionary:(GPBInt64UInt64Dictionary *)dictionary { 7875 self = [self initWithValues:NULL forKeys:NULL count:0]; 7876 if (self) { 7877 if (dictionary) { 7878 [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 7879 } 7880 } 7881 return self; 7882 } 7883 7884 - (instancetype)initWithCapacity:(NSUInteger)numItems { 7885 #pragma unused(numItems) 7886 return [self initWithValues:NULL forKeys:NULL count:0]; 7887 } 7888 7889 - (void)dealloc { 7890 NSAssert(!_autocreator, 7891 @"%@: Autocreator must be cleared before release, autocreator: %@", 7892 [self class], _autocreator); 7893 [_dictionary release]; 7894 [super dealloc]; 7895 } 7896 7897 - (instancetype)copyWithZone:(NSZone *)zone { 7898 return [[GPBInt64UInt64Dictionary allocWithZone:zone] initWithDictionary:self]; 7899 } 7900 7901 - (BOOL)isEqual:(GPBInt64UInt64Dictionary *)other { 7902 if (self == other) { 7903 return YES; 7904 } 7905 if (![other isKindOfClass:[GPBInt64UInt64Dictionary class]]) { 7906 return NO; 7907 } 7908 return [_dictionary isEqual:other->_dictionary]; 7909 } 7910 7911 - (NSUInteger)hash { 7912 return _dictionary.count; 7913 } 7914 7915 - (NSString *)description { 7916 return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 7917 } 7918 7919 - (NSUInteger)count { 7920 return _dictionary.count; 7921 } 7922 7923 - (void)enumerateKeysAndValuesUsingBlock: 7924 (void (^)(int64_t key, uint64_t value, BOOL *stop))block { 7925 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 7926 NSNumber *aValue, 7927 BOOL *stop) { 7928 block([aKey longLongValue], [aValue unsignedLongLongValue], stop); 7929 }]; 7930 } 7931 7932 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 7933 NSUInteger count = _dictionary.count; 7934 if (count == 0) { 7935 return 0; 7936 } 7937 7938 GPBDataType valueDataType = GPBGetFieldDataType(field); 7939 GPBDataType keyDataType = field.mapKeyDataType; 7940 __block size_t result = 0; 7941 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 7942 NSNumber *aValue, 7943 BOOL *stop) { 7944 #pragma unused(stop) 7945 size_t msgSize = ComputeDictInt64FieldSize([aKey longLongValue], kMapKeyFieldNumber, keyDataType); 7946 msgSize += ComputeDictUInt64FieldSize([aValue unsignedLongLongValue], kMapValueFieldNumber, valueDataType); 7947 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 7948 }]; 7949 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 7950 result += tagSize * count; 7951 return result; 7952 } 7953 7954 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 7955 asField:(GPBFieldDescriptor *)field { 7956 GPBDataType valueDataType = GPBGetFieldDataType(field); 7957 GPBDataType keyDataType = field.mapKeyDataType; 7958 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 7959 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 7960 NSNumber *aValue, 7961 BOOL *stop) { 7962 #pragma unused(stop) 7963 // Write the tag. 7964 [outputStream writeInt32NoTag:tag]; 7965 // Write the size of the message. 7966 size_t msgSize = ComputeDictInt64FieldSize([aKey longLongValue], kMapKeyFieldNumber, keyDataType); 7967 msgSize += ComputeDictUInt64FieldSize([aValue unsignedLongLongValue], kMapValueFieldNumber, valueDataType); 7968 [outputStream writeInt32NoTag:(int32_t)msgSize]; 7969 // Write the fields. 7970 WriteDictInt64Field(outputStream, [aKey longLongValue], kMapKeyFieldNumber, keyDataType); 7971 WriteDictUInt64Field(outputStream, [aValue unsignedLongLongValue], kMapValueFieldNumber, valueDataType); 7972 }]; 7973 } 7974 7975 - (void)setGPBGenericValue:(GPBGenericValue *)value 7976 forGPBGenericValueKey:(GPBGenericValue *)key { 7977 [_dictionary setObject:@(value->valueUInt64) forKey:@(key->valueInt64)]; 7978 } 7979 7980 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 7981 [self enumerateKeysAndValuesUsingBlock:^(int64_t key, uint64_t value, BOOL *stop) { 7982 #pragma unused(stop) 7983 block([NSString stringWithFormat:@"%lld", key], [NSString stringWithFormat:@"%llu", value]); 7984 }]; 7985 } 7986 7987 - (BOOL)valueForKey:(int64_t)key value:(uint64_t *)value { 7988 NSNumber *wrapped = [_dictionary objectForKey:@(key)]; 7989 if (wrapped && value) { 7990 *value = [wrapped unsignedLongLongValue]; 7991 } 7992 return (wrapped != NULL); 7993 } 7994 7995 - (void)addEntriesFromDictionary:(GPBInt64UInt64Dictionary *)otherDictionary { 7996 if (otherDictionary) { 7997 [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 7998 if (_autocreator) { 7999 GPBAutocreatedDictionaryModified(_autocreator, self); 8000 } 8001 } 8002 } 8003 8004 - (void)setValue:(uint64_t)value forKey:(int64_t)key { 8005 [_dictionary setObject:@(value) forKey:@(key)]; 8006 if (_autocreator) { 8007 GPBAutocreatedDictionaryModified(_autocreator, self); 8008 } 8009 } 8010 8011 - (void)removeValueForKey:(int64_t)aKey { 8012 [_dictionary removeObjectForKey:@(aKey)]; 8013 } 8014 8015 - (void)removeAll { 8016 [_dictionary removeAllObjects]; 8017 } 8018 8019 @end 8020 8021 #pragma mark - Int64 -> Int64 8022 8023 @implementation GPBInt64Int64Dictionary { 8024 @package 8025 NSMutableDictionary *_dictionary; 8026 } 8027 8028 + (instancetype)dictionary { 8029 return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; 8030 } 8031 8032 + (instancetype)dictionaryWithValue:(int64_t)value 8033 forKey:(int64_t)key { 8034 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 8035 // on to get the type correct. 8036 return [[(GPBInt64Int64Dictionary*)[self alloc] initWithValues:&value 8037 forKeys:&key 8038 count:1] autorelease]; 8039 } 8040 8041 + (instancetype)dictionaryWithValues:(const int64_t [])values 8042 forKeys:(const int64_t [])keys 8043 count:(NSUInteger)count { 8044 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 8045 // on to get the type correct. 8046 return [[(GPBInt64Int64Dictionary*)[self alloc] initWithValues:values 8047 forKeys:keys 8048 count:count] autorelease]; 8049 } 8050 8051 + (instancetype)dictionaryWithDictionary:(GPBInt64Int64Dictionary *)dictionary { 8052 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 8053 // on to get the type correct. 8054 return [[(GPBInt64Int64Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 8055 } 8056 8057 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 8058 return [[[self alloc] initWithCapacity:numItems] autorelease]; 8059 } 8060 8061 - (instancetype)init { 8062 return [self initWithValues:NULL forKeys:NULL count:0]; 8063 } 8064 8065 - (instancetype)initWithValues:(const int64_t [])values 8066 forKeys:(const int64_t [])keys 8067 count:(NSUInteger)count { 8068 self = [super init]; 8069 if (self) { 8070 _dictionary = [[NSMutableDictionary alloc] init]; 8071 if (count && values && keys) { 8072 for (NSUInteger i = 0; i < count; ++i) { 8073 [_dictionary setObject:@(values[i]) forKey:@(keys[i])]; 8074 } 8075 } 8076 } 8077 return self; 8078 } 8079 8080 - (instancetype)initWithDictionary:(GPBInt64Int64Dictionary *)dictionary { 8081 self = [self initWithValues:NULL forKeys:NULL count:0]; 8082 if (self) { 8083 if (dictionary) { 8084 [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 8085 } 8086 } 8087 return self; 8088 } 8089 8090 - (instancetype)initWithCapacity:(NSUInteger)numItems { 8091 #pragma unused(numItems) 8092 return [self initWithValues:NULL forKeys:NULL count:0]; 8093 } 8094 8095 - (void)dealloc { 8096 NSAssert(!_autocreator, 8097 @"%@: Autocreator must be cleared before release, autocreator: %@", 8098 [self class], _autocreator); 8099 [_dictionary release]; 8100 [super dealloc]; 8101 } 8102 8103 - (instancetype)copyWithZone:(NSZone *)zone { 8104 return [[GPBInt64Int64Dictionary allocWithZone:zone] initWithDictionary:self]; 8105 } 8106 8107 - (BOOL)isEqual:(GPBInt64Int64Dictionary *)other { 8108 if (self == other) { 8109 return YES; 8110 } 8111 if (![other isKindOfClass:[GPBInt64Int64Dictionary class]]) { 8112 return NO; 8113 } 8114 return [_dictionary isEqual:other->_dictionary]; 8115 } 8116 8117 - (NSUInteger)hash { 8118 return _dictionary.count; 8119 } 8120 8121 - (NSString *)description { 8122 return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 8123 } 8124 8125 - (NSUInteger)count { 8126 return _dictionary.count; 8127 } 8128 8129 - (void)enumerateKeysAndValuesUsingBlock: 8130 (void (^)(int64_t key, int64_t value, BOOL *stop))block { 8131 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 8132 NSNumber *aValue, 8133 BOOL *stop) { 8134 block([aKey longLongValue], [aValue longLongValue], stop); 8135 }]; 8136 } 8137 8138 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 8139 NSUInteger count = _dictionary.count; 8140 if (count == 0) { 8141 return 0; 8142 } 8143 8144 GPBDataType valueDataType = GPBGetFieldDataType(field); 8145 GPBDataType keyDataType = field.mapKeyDataType; 8146 __block size_t result = 0; 8147 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 8148 NSNumber *aValue, 8149 BOOL *stop) { 8150 #pragma unused(stop) 8151 size_t msgSize = ComputeDictInt64FieldSize([aKey longLongValue], kMapKeyFieldNumber, keyDataType); 8152 msgSize += ComputeDictInt64FieldSize([aValue longLongValue], kMapValueFieldNumber, valueDataType); 8153 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 8154 }]; 8155 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 8156 result += tagSize * count; 8157 return result; 8158 } 8159 8160 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 8161 asField:(GPBFieldDescriptor *)field { 8162 GPBDataType valueDataType = GPBGetFieldDataType(field); 8163 GPBDataType keyDataType = field.mapKeyDataType; 8164 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 8165 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 8166 NSNumber *aValue, 8167 BOOL *stop) { 8168 #pragma unused(stop) 8169 // Write the tag. 8170 [outputStream writeInt32NoTag:tag]; 8171 // Write the size of the message. 8172 size_t msgSize = ComputeDictInt64FieldSize([aKey longLongValue], kMapKeyFieldNumber, keyDataType); 8173 msgSize += ComputeDictInt64FieldSize([aValue longLongValue], kMapValueFieldNumber, valueDataType); 8174 [outputStream writeInt32NoTag:(int32_t)msgSize]; 8175 // Write the fields. 8176 WriteDictInt64Field(outputStream, [aKey longLongValue], kMapKeyFieldNumber, keyDataType); 8177 WriteDictInt64Field(outputStream, [aValue longLongValue], kMapValueFieldNumber, valueDataType); 8178 }]; 8179 } 8180 8181 - (void)setGPBGenericValue:(GPBGenericValue *)value 8182 forGPBGenericValueKey:(GPBGenericValue *)key { 8183 [_dictionary setObject:@(value->valueInt64) forKey:@(key->valueInt64)]; 8184 } 8185 8186 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 8187 [self enumerateKeysAndValuesUsingBlock:^(int64_t key, int64_t value, BOOL *stop) { 8188 #pragma unused(stop) 8189 block([NSString stringWithFormat:@"%lld", key], [NSString stringWithFormat:@"%lld", value]); 8190 }]; 8191 } 8192 8193 - (BOOL)valueForKey:(int64_t)key value:(int64_t *)value { 8194 NSNumber *wrapped = [_dictionary objectForKey:@(key)]; 8195 if (wrapped && value) { 8196 *value = [wrapped longLongValue]; 8197 } 8198 return (wrapped != NULL); 8199 } 8200 8201 - (void)addEntriesFromDictionary:(GPBInt64Int64Dictionary *)otherDictionary { 8202 if (otherDictionary) { 8203 [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 8204 if (_autocreator) { 8205 GPBAutocreatedDictionaryModified(_autocreator, self); 8206 } 8207 } 8208 } 8209 8210 - (void)setValue:(int64_t)value forKey:(int64_t)key { 8211 [_dictionary setObject:@(value) forKey:@(key)]; 8212 if (_autocreator) { 8213 GPBAutocreatedDictionaryModified(_autocreator, self); 8214 } 8215 } 8216 8217 - (void)removeValueForKey:(int64_t)aKey { 8218 [_dictionary removeObjectForKey:@(aKey)]; 8219 } 8220 8221 - (void)removeAll { 8222 [_dictionary removeAllObjects]; 8223 } 8224 8225 @end 8226 8227 #pragma mark - Int64 -> Bool 8228 8229 @implementation GPBInt64BoolDictionary { 8230 @package 8231 NSMutableDictionary *_dictionary; 8232 } 8233 8234 + (instancetype)dictionary { 8235 return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; 8236 } 8237 8238 + (instancetype)dictionaryWithValue:(BOOL)value 8239 forKey:(int64_t)key { 8240 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 8241 // on to get the type correct. 8242 return [[(GPBInt64BoolDictionary*)[self alloc] initWithValues:&value 8243 forKeys:&key 8244 count:1] autorelease]; 8245 } 8246 8247 + (instancetype)dictionaryWithValues:(const BOOL [])values 8248 forKeys:(const int64_t [])keys 8249 count:(NSUInteger)count { 8250 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 8251 // on to get the type correct. 8252 return [[(GPBInt64BoolDictionary*)[self alloc] initWithValues:values 8253 forKeys:keys 8254 count:count] autorelease]; 8255 } 8256 8257 + (instancetype)dictionaryWithDictionary:(GPBInt64BoolDictionary *)dictionary { 8258 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 8259 // on to get the type correct. 8260 return [[(GPBInt64BoolDictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 8261 } 8262 8263 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 8264 return [[[self alloc] initWithCapacity:numItems] autorelease]; 8265 } 8266 8267 - (instancetype)init { 8268 return [self initWithValues:NULL forKeys:NULL count:0]; 8269 } 8270 8271 - (instancetype)initWithValues:(const BOOL [])values 8272 forKeys:(const int64_t [])keys 8273 count:(NSUInteger)count { 8274 self = [super init]; 8275 if (self) { 8276 _dictionary = [[NSMutableDictionary alloc] init]; 8277 if (count && values && keys) { 8278 for (NSUInteger i = 0; i < count; ++i) { 8279 [_dictionary setObject:@(values[i]) forKey:@(keys[i])]; 8280 } 8281 } 8282 } 8283 return self; 8284 } 8285 8286 - (instancetype)initWithDictionary:(GPBInt64BoolDictionary *)dictionary { 8287 self = [self initWithValues:NULL forKeys:NULL count:0]; 8288 if (self) { 8289 if (dictionary) { 8290 [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 8291 } 8292 } 8293 return self; 8294 } 8295 8296 - (instancetype)initWithCapacity:(NSUInteger)numItems { 8297 #pragma unused(numItems) 8298 return [self initWithValues:NULL forKeys:NULL count:0]; 8299 } 8300 8301 - (void)dealloc { 8302 NSAssert(!_autocreator, 8303 @"%@: Autocreator must be cleared before release, autocreator: %@", 8304 [self class], _autocreator); 8305 [_dictionary release]; 8306 [super dealloc]; 8307 } 8308 8309 - (instancetype)copyWithZone:(NSZone *)zone { 8310 return [[GPBInt64BoolDictionary allocWithZone:zone] initWithDictionary:self]; 8311 } 8312 8313 - (BOOL)isEqual:(GPBInt64BoolDictionary *)other { 8314 if (self == other) { 8315 return YES; 8316 } 8317 if (![other isKindOfClass:[GPBInt64BoolDictionary class]]) { 8318 return NO; 8319 } 8320 return [_dictionary isEqual:other->_dictionary]; 8321 } 8322 8323 - (NSUInteger)hash { 8324 return _dictionary.count; 8325 } 8326 8327 - (NSString *)description { 8328 return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 8329 } 8330 8331 - (NSUInteger)count { 8332 return _dictionary.count; 8333 } 8334 8335 - (void)enumerateKeysAndValuesUsingBlock: 8336 (void (^)(int64_t key, BOOL value, BOOL *stop))block { 8337 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 8338 NSNumber *aValue, 8339 BOOL *stop) { 8340 block([aKey longLongValue], [aValue boolValue], stop); 8341 }]; 8342 } 8343 8344 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 8345 NSUInteger count = _dictionary.count; 8346 if (count == 0) { 8347 return 0; 8348 } 8349 8350 GPBDataType valueDataType = GPBGetFieldDataType(field); 8351 GPBDataType keyDataType = field.mapKeyDataType; 8352 __block size_t result = 0; 8353 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 8354 NSNumber *aValue, 8355 BOOL *stop) { 8356 #pragma unused(stop) 8357 size_t msgSize = ComputeDictInt64FieldSize([aKey longLongValue], kMapKeyFieldNumber, keyDataType); 8358 msgSize += ComputeDictBoolFieldSize([aValue boolValue], kMapValueFieldNumber, valueDataType); 8359 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 8360 }]; 8361 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 8362 result += tagSize * count; 8363 return result; 8364 } 8365 8366 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 8367 asField:(GPBFieldDescriptor *)field { 8368 GPBDataType valueDataType = GPBGetFieldDataType(field); 8369 GPBDataType keyDataType = field.mapKeyDataType; 8370 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 8371 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 8372 NSNumber *aValue, 8373 BOOL *stop) { 8374 #pragma unused(stop) 8375 // Write the tag. 8376 [outputStream writeInt32NoTag:tag]; 8377 // Write the size of the message. 8378 size_t msgSize = ComputeDictInt64FieldSize([aKey longLongValue], kMapKeyFieldNumber, keyDataType); 8379 msgSize += ComputeDictBoolFieldSize([aValue boolValue], kMapValueFieldNumber, valueDataType); 8380 [outputStream writeInt32NoTag:(int32_t)msgSize]; 8381 // Write the fields. 8382 WriteDictInt64Field(outputStream, [aKey longLongValue], kMapKeyFieldNumber, keyDataType); 8383 WriteDictBoolField(outputStream, [aValue boolValue], kMapValueFieldNumber, valueDataType); 8384 }]; 8385 } 8386 8387 - (void)setGPBGenericValue:(GPBGenericValue *)value 8388 forGPBGenericValueKey:(GPBGenericValue *)key { 8389 [_dictionary setObject:@(value->valueBool) forKey:@(key->valueInt64)]; 8390 } 8391 8392 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 8393 [self enumerateKeysAndValuesUsingBlock:^(int64_t key, BOOL value, BOOL *stop) { 8394 #pragma unused(stop) 8395 block([NSString stringWithFormat:@"%lld", key], (value ? @"true" : @"false")); 8396 }]; 8397 } 8398 8399 - (BOOL)valueForKey:(int64_t)key value:(BOOL *)value { 8400 NSNumber *wrapped = [_dictionary objectForKey:@(key)]; 8401 if (wrapped && value) { 8402 *value = [wrapped boolValue]; 8403 } 8404 return (wrapped != NULL); 8405 } 8406 8407 - (void)addEntriesFromDictionary:(GPBInt64BoolDictionary *)otherDictionary { 8408 if (otherDictionary) { 8409 [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 8410 if (_autocreator) { 8411 GPBAutocreatedDictionaryModified(_autocreator, self); 8412 } 8413 } 8414 } 8415 8416 - (void)setValue:(BOOL)value forKey:(int64_t)key { 8417 [_dictionary setObject:@(value) forKey:@(key)]; 8418 if (_autocreator) { 8419 GPBAutocreatedDictionaryModified(_autocreator, self); 8420 } 8421 } 8422 8423 - (void)removeValueForKey:(int64_t)aKey { 8424 [_dictionary removeObjectForKey:@(aKey)]; 8425 } 8426 8427 - (void)removeAll { 8428 [_dictionary removeAllObjects]; 8429 } 8430 8431 @end 8432 8433 #pragma mark - Int64 -> Float 8434 8435 @implementation GPBInt64FloatDictionary { 8436 @package 8437 NSMutableDictionary *_dictionary; 8438 } 8439 8440 + (instancetype)dictionary { 8441 return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; 8442 } 8443 8444 + (instancetype)dictionaryWithValue:(float)value 8445 forKey:(int64_t)key { 8446 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 8447 // on to get the type correct. 8448 return [[(GPBInt64FloatDictionary*)[self alloc] initWithValues:&value 8449 forKeys:&key 8450 count:1] autorelease]; 8451 } 8452 8453 + (instancetype)dictionaryWithValues:(const float [])values 8454 forKeys:(const int64_t [])keys 8455 count:(NSUInteger)count { 8456 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 8457 // on to get the type correct. 8458 return [[(GPBInt64FloatDictionary*)[self alloc] initWithValues:values 8459 forKeys:keys 8460 count:count] autorelease]; 8461 } 8462 8463 + (instancetype)dictionaryWithDictionary:(GPBInt64FloatDictionary *)dictionary { 8464 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 8465 // on to get the type correct. 8466 return [[(GPBInt64FloatDictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 8467 } 8468 8469 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 8470 return [[[self alloc] initWithCapacity:numItems] autorelease]; 8471 } 8472 8473 - (instancetype)init { 8474 return [self initWithValues:NULL forKeys:NULL count:0]; 8475 } 8476 8477 - (instancetype)initWithValues:(const float [])values 8478 forKeys:(const int64_t [])keys 8479 count:(NSUInteger)count { 8480 self = [super init]; 8481 if (self) { 8482 _dictionary = [[NSMutableDictionary alloc] init]; 8483 if (count && values && keys) { 8484 for (NSUInteger i = 0; i < count; ++i) { 8485 [_dictionary setObject:@(values[i]) forKey:@(keys[i])]; 8486 } 8487 } 8488 } 8489 return self; 8490 } 8491 8492 - (instancetype)initWithDictionary:(GPBInt64FloatDictionary *)dictionary { 8493 self = [self initWithValues:NULL forKeys:NULL count:0]; 8494 if (self) { 8495 if (dictionary) { 8496 [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 8497 } 8498 } 8499 return self; 8500 } 8501 8502 - (instancetype)initWithCapacity:(NSUInteger)numItems { 8503 #pragma unused(numItems) 8504 return [self initWithValues:NULL forKeys:NULL count:0]; 8505 } 8506 8507 - (void)dealloc { 8508 NSAssert(!_autocreator, 8509 @"%@: Autocreator must be cleared before release, autocreator: %@", 8510 [self class], _autocreator); 8511 [_dictionary release]; 8512 [super dealloc]; 8513 } 8514 8515 - (instancetype)copyWithZone:(NSZone *)zone { 8516 return [[GPBInt64FloatDictionary allocWithZone:zone] initWithDictionary:self]; 8517 } 8518 8519 - (BOOL)isEqual:(GPBInt64FloatDictionary *)other { 8520 if (self == other) { 8521 return YES; 8522 } 8523 if (![other isKindOfClass:[GPBInt64FloatDictionary class]]) { 8524 return NO; 8525 } 8526 return [_dictionary isEqual:other->_dictionary]; 8527 } 8528 8529 - (NSUInteger)hash { 8530 return _dictionary.count; 8531 } 8532 8533 - (NSString *)description { 8534 return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 8535 } 8536 8537 - (NSUInteger)count { 8538 return _dictionary.count; 8539 } 8540 8541 - (void)enumerateKeysAndValuesUsingBlock: 8542 (void (^)(int64_t key, float value, BOOL *stop))block { 8543 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 8544 NSNumber *aValue, 8545 BOOL *stop) { 8546 block([aKey longLongValue], [aValue floatValue], stop); 8547 }]; 8548 } 8549 8550 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 8551 NSUInteger count = _dictionary.count; 8552 if (count == 0) { 8553 return 0; 8554 } 8555 8556 GPBDataType valueDataType = GPBGetFieldDataType(field); 8557 GPBDataType keyDataType = field.mapKeyDataType; 8558 __block size_t result = 0; 8559 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 8560 NSNumber *aValue, 8561 BOOL *stop) { 8562 #pragma unused(stop) 8563 size_t msgSize = ComputeDictInt64FieldSize([aKey longLongValue], kMapKeyFieldNumber, keyDataType); 8564 msgSize += ComputeDictFloatFieldSize([aValue floatValue], kMapValueFieldNumber, valueDataType); 8565 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 8566 }]; 8567 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 8568 result += tagSize * count; 8569 return result; 8570 } 8571 8572 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 8573 asField:(GPBFieldDescriptor *)field { 8574 GPBDataType valueDataType = GPBGetFieldDataType(field); 8575 GPBDataType keyDataType = field.mapKeyDataType; 8576 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 8577 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 8578 NSNumber *aValue, 8579 BOOL *stop) { 8580 #pragma unused(stop) 8581 // Write the tag. 8582 [outputStream writeInt32NoTag:tag]; 8583 // Write the size of the message. 8584 size_t msgSize = ComputeDictInt64FieldSize([aKey longLongValue], kMapKeyFieldNumber, keyDataType); 8585 msgSize += ComputeDictFloatFieldSize([aValue floatValue], kMapValueFieldNumber, valueDataType); 8586 [outputStream writeInt32NoTag:(int32_t)msgSize]; 8587 // Write the fields. 8588 WriteDictInt64Field(outputStream, [aKey longLongValue], kMapKeyFieldNumber, keyDataType); 8589 WriteDictFloatField(outputStream, [aValue floatValue], kMapValueFieldNumber, valueDataType); 8590 }]; 8591 } 8592 8593 - (void)setGPBGenericValue:(GPBGenericValue *)value 8594 forGPBGenericValueKey:(GPBGenericValue *)key { 8595 [_dictionary setObject:@(value->valueFloat) forKey:@(key->valueInt64)]; 8596 } 8597 8598 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 8599 [self enumerateKeysAndValuesUsingBlock:^(int64_t key, float value, BOOL *stop) { 8600 #pragma unused(stop) 8601 block([NSString stringWithFormat:@"%lld", key], [NSString stringWithFormat:@"%.*g", FLT_DIG, value]); 8602 }]; 8603 } 8604 8605 - (BOOL)valueForKey:(int64_t)key value:(float *)value { 8606 NSNumber *wrapped = [_dictionary objectForKey:@(key)]; 8607 if (wrapped && value) { 8608 *value = [wrapped floatValue]; 8609 } 8610 return (wrapped != NULL); 8611 } 8612 8613 - (void)addEntriesFromDictionary:(GPBInt64FloatDictionary *)otherDictionary { 8614 if (otherDictionary) { 8615 [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 8616 if (_autocreator) { 8617 GPBAutocreatedDictionaryModified(_autocreator, self); 8618 } 8619 } 8620 } 8621 8622 - (void)setValue:(float)value forKey:(int64_t)key { 8623 [_dictionary setObject:@(value) forKey:@(key)]; 8624 if (_autocreator) { 8625 GPBAutocreatedDictionaryModified(_autocreator, self); 8626 } 8627 } 8628 8629 - (void)removeValueForKey:(int64_t)aKey { 8630 [_dictionary removeObjectForKey:@(aKey)]; 8631 } 8632 8633 - (void)removeAll { 8634 [_dictionary removeAllObjects]; 8635 } 8636 8637 @end 8638 8639 #pragma mark - Int64 -> Double 8640 8641 @implementation GPBInt64DoubleDictionary { 8642 @package 8643 NSMutableDictionary *_dictionary; 8644 } 8645 8646 + (instancetype)dictionary { 8647 return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; 8648 } 8649 8650 + (instancetype)dictionaryWithValue:(double)value 8651 forKey:(int64_t)key { 8652 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 8653 // on to get the type correct. 8654 return [[(GPBInt64DoubleDictionary*)[self alloc] initWithValues:&value 8655 forKeys:&key 8656 count:1] autorelease]; 8657 } 8658 8659 + (instancetype)dictionaryWithValues:(const double [])values 8660 forKeys:(const int64_t [])keys 8661 count:(NSUInteger)count { 8662 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 8663 // on to get the type correct. 8664 return [[(GPBInt64DoubleDictionary*)[self alloc] initWithValues:values 8665 forKeys:keys 8666 count:count] autorelease]; 8667 } 8668 8669 + (instancetype)dictionaryWithDictionary:(GPBInt64DoubleDictionary *)dictionary { 8670 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 8671 // on to get the type correct. 8672 return [[(GPBInt64DoubleDictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 8673 } 8674 8675 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 8676 return [[[self alloc] initWithCapacity:numItems] autorelease]; 8677 } 8678 8679 - (instancetype)init { 8680 return [self initWithValues:NULL forKeys:NULL count:0]; 8681 } 8682 8683 - (instancetype)initWithValues:(const double [])values 8684 forKeys:(const int64_t [])keys 8685 count:(NSUInteger)count { 8686 self = [super init]; 8687 if (self) { 8688 _dictionary = [[NSMutableDictionary alloc] init]; 8689 if (count && values && keys) { 8690 for (NSUInteger i = 0; i < count; ++i) { 8691 [_dictionary setObject:@(values[i]) forKey:@(keys[i])]; 8692 } 8693 } 8694 } 8695 return self; 8696 } 8697 8698 - (instancetype)initWithDictionary:(GPBInt64DoubleDictionary *)dictionary { 8699 self = [self initWithValues:NULL forKeys:NULL count:0]; 8700 if (self) { 8701 if (dictionary) { 8702 [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 8703 } 8704 } 8705 return self; 8706 } 8707 8708 - (instancetype)initWithCapacity:(NSUInteger)numItems { 8709 #pragma unused(numItems) 8710 return [self initWithValues:NULL forKeys:NULL count:0]; 8711 } 8712 8713 - (void)dealloc { 8714 NSAssert(!_autocreator, 8715 @"%@: Autocreator must be cleared before release, autocreator: %@", 8716 [self class], _autocreator); 8717 [_dictionary release]; 8718 [super dealloc]; 8719 } 8720 8721 - (instancetype)copyWithZone:(NSZone *)zone { 8722 return [[GPBInt64DoubleDictionary allocWithZone:zone] initWithDictionary:self]; 8723 } 8724 8725 - (BOOL)isEqual:(GPBInt64DoubleDictionary *)other { 8726 if (self == other) { 8727 return YES; 8728 } 8729 if (![other isKindOfClass:[GPBInt64DoubleDictionary class]]) { 8730 return NO; 8731 } 8732 return [_dictionary isEqual:other->_dictionary]; 8733 } 8734 8735 - (NSUInteger)hash { 8736 return _dictionary.count; 8737 } 8738 8739 - (NSString *)description { 8740 return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 8741 } 8742 8743 - (NSUInteger)count { 8744 return _dictionary.count; 8745 } 8746 8747 - (void)enumerateKeysAndValuesUsingBlock: 8748 (void (^)(int64_t key, double value, BOOL *stop))block { 8749 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 8750 NSNumber *aValue, 8751 BOOL *stop) { 8752 block([aKey longLongValue], [aValue doubleValue], stop); 8753 }]; 8754 } 8755 8756 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 8757 NSUInteger count = _dictionary.count; 8758 if (count == 0) { 8759 return 0; 8760 } 8761 8762 GPBDataType valueDataType = GPBGetFieldDataType(field); 8763 GPBDataType keyDataType = field.mapKeyDataType; 8764 __block size_t result = 0; 8765 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 8766 NSNumber *aValue, 8767 BOOL *stop) { 8768 #pragma unused(stop) 8769 size_t msgSize = ComputeDictInt64FieldSize([aKey longLongValue], kMapKeyFieldNumber, keyDataType); 8770 msgSize += ComputeDictDoubleFieldSize([aValue doubleValue], kMapValueFieldNumber, valueDataType); 8771 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 8772 }]; 8773 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 8774 result += tagSize * count; 8775 return result; 8776 } 8777 8778 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 8779 asField:(GPBFieldDescriptor *)field { 8780 GPBDataType valueDataType = GPBGetFieldDataType(field); 8781 GPBDataType keyDataType = field.mapKeyDataType; 8782 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 8783 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 8784 NSNumber *aValue, 8785 BOOL *stop) { 8786 #pragma unused(stop) 8787 // Write the tag. 8788 [outputStream writeInt32NoTag:tag]; 8789 // Write the size of the message. 8790 size_t msgSize = ComputeDictInt64FieldSize([aKey longLongValue], kMapKeyFieldNumber, keyDataType); 8791 msgSize += ComputeDictDoubleFieldSize([aValue doubleValue], kMapValueFieldNumber, valueDataType); 8792 [outputStream writeInt32NoTag:(int32_t)msgSize]; 8793 // Write the fields. 8794 WriteDictInt64Field(outputStream, [aKey longLongValue], kMapKeyFieldNumber, keyDataType); 8795 WriteDictDoubleField(outputStream, [aValue doubleValue], kMapValueFieldNumber, valueDataType); 8796 }]; 8797 } 8798 8799 - (void)setGPBGenericValue:(GPBGenericValue *)value 8800 forGPBGenericValueKey:(GPBGenericValue *)key { 8801 [_dictionary setObject:@(value->valueDouble) forKey:@(key->valueInt64)]; 8802 } 8803 8804 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 8805 [self enumerateKeysAndValuesUsingBlock:^(int64_t key, double value, BOOL *stop) { 8806 #pragma unused(stop) 8807 block([NSString stringWithFormat:@"%lld", key], [NSString stringWithFormat:@"%.*lg", DBL_DIG, value]); 8808 }]; 8809 } 8810 8811 - (BOOL)valueForKey:(int64_t)key value:(double *)value { 8812 NSNumber *wrapped = [_dictionary objectForKey:@(key)]; 8813 if (wrapped && value) { 8814 *value = [wrapped doubleValue]; 8815 } 8816 return (wrapped != NULL); 8817 } 8818 8819 - (void)addEntriesFromDictionary:(GPBInt64DoubleDictionary *)otherDictionary { 8820 if (otherDictionary) { 8821 [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 8822 if (_autocreator) { 8823 GPBAutocreatedDictionaryModified(_autocreator, self); 8824 } 8825 } 8826 } 8827 8828 - (void)setValue:(double)value forKey:(int64_t)key { 8829 [_dictionary setObject:@(value) forKey:@(key)]; 8830 if (_autocreator) { 8831 GPBAutocreatedDictionaryModified(_autocreator, self); 8832 } 8833 } 8834 8835 - (void)removeValueForKey:(int64_t)aKey { 8836 [_dictionary removeObjectForKey:@(aKey)]; 8837 } 8838 8839 - (void)removeAll { 8840 [_dictionary removeAllObjects]; 8841 } 8842 8843 @end 8844 8845 #pragma mark - Int64 -> Enum 8846 8847 @implementation GPBInt64EnumDictionary { 8848 @package 8849 NSMutableDictionary *_dictionary; 8850 GPBEnumValidationFunc _validationFunc; 8851 } 8852 8853 @synthesize validationFunc = _validationFunc; 8854 8855 + (instancetype)dictionary { 8856 return [[[self alloc] initWithValidationFunction:NULL 8857 rawValues:NULL 8858 forKeys:NULL 8859 count:0] autorelease]; 8860 } 8861 8862 + (instancetype)dictionaryWithValidationFunction:(GPBEnumValidationFunc)func { 8863 return [[[self alloc] initWithValidationFunction:func 8864 rawValues:NULL 8865 forKeys:NULL 8866 count:0] autorelease]; 8867 } 8868 8869 + (instancetype)dictionaryWithValidationFunction:(GPBEnumValidationFunc)func 8870 rawValue:(int32_t)rawValue 8871 forKey:(int64_t)key { 8872 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 8873 // on to get the type correct. 8874 return [[(GPBInt64EnumDictionary*)[self alloc] initWithValidationFunction:func 8875 rawValues:&rawValue 8876 forKeys:&key 8877 count:1] autorelease]; 8878 } 8879 8880 + (instancetype)dictionaryWithValidationFunction:(GPBEnumValidationFunc)func 8881 rawValues:(const int32_t [])rawValues 8882 forKeys:(const int64_t [])keys 8883 count:(NSUInteger)count { 8884 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 8885 // on to get the type correct. 8886 return [[(GPBInt64EnumDictionary*)[self alloc] initWithValidationFunction:func 8887 rawValues:rawValues 8888 forKeys:keys 8889 count:count] autorelease]; 8890 } 8891 8892 + (instancetype)dictionaryWithDictionary:(GPBInt64EnumDictionary *)dictionary { 8893 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 8894 // on to get the type correct. 8895 return [[(GPBInt64EnumDictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 8896 } 8897 8898 + (instancetype)dictionaryWithValidationFunction:(GPBEnumValidationFunc)func 8899 capacity:(NSUInteger)numItems { 8900 return [[[self alloc] initWithValidationFunction:func capacity:numItems] autorelease]; 8901 } 8902 8903 - (instancetype)init { 8904 return [self initWithValidationFunction:NULL rawValues:NULL forKeys:NULL count:0]; 8905 } 8906 8907 - (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func { 8908 return [self initWithValidationFunction:func rawValues:NULL forKeys:NULL count:0]; 8909 } 8910 8911 - (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func 8912 rawValues:(const int32_t [])rawValues 8913 forKeys:(const int64_t [])keys 8914 count:(NSUInteger)count { 8915 self = [super init]; 8916 if (self) { 8917 _dictionary = [[NSMutableDictionary alloc] init]; 8918 _validationFunc = (func != NULL ? func : DictDefault_IsValidValue); 8919 if (count && rawValues && keys) { 8920 for (NSUInteger i = 0; i < count; ++i) { 8921 [_dictionary setObject:@(rawValues[i]) forKey:@(keys[i])]; 8922 } 8923 } 8924 } 8925 return self; 8926 } 8927 8928 - (instancetype)initWithDictionary:(GPBInt64EnumDictionary *)dictionary { 8929 self = [self initWithValidationFunction:dictionary.validationFunc 8930 rawValues:NULL 8931 forKeys:NULL 8932 count:0]; 8933 if (self) { 8934 if (dictionary) { 8935 [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 8936 } 8937 } 8938 return self; 8939 } 8940 8941 - (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func 8942 capacity:(NSUInteger)numItems { 8943 #pragma unused(numItems) 8944 return [self initWithValidationFunction:func rawValues:NULL forKeys:NULL count:0]; 8945 } 8946 8947 - (void)dealloc { 8948 NSAssert(!_autocreator, 8949 @"%@: Autocreator must be cleared before release, autocreator: %@", 8950 [self class], _autocreator); 8951 [_dictionary release]; 8952 [super dealloc]; 8953 } 8954 8955 - (instancetype)copyWithZone:(NSZone *)zone { 8956 return [[GPBInt64EnumDictionary allocWithZone:zone] initWithDictionary:self]; 8957 } 8958 8959 - (BOOL)isEqual:(GPBInt64EnumDictionary *)other { 8960 if (self == other) { 8961 return YES; 8962 } 8963 if (![other isKindOfClass:[GPBInt64EnumDictionary class]]) { 8964 return NO; 8965 } 8966 return [_dictionary isEqual:other->_dictionary]; 8967 } 8968 8969 - (NSUInteger)hash { 8970 return _dictionary.count; 8971 } 8972 8973 - (NSString *)description { 8974 return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 8975 } 8976 8977 - (NSUInteger)count { 8978 return _dictionary.count; 8979 } 8980 8981 - (void)enumerateKeysAndRawValuesUsingBlock: 8982 (void (^)(int64_t key, int32_t value, BOOL *stop))block { 8983 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 8984 NSNumber *aValue, 8985 BOOL *stop) { 8986 block([aKey longLongValue], [aValue intValue], stop); 8987 }]; 8988 } 8989 8990 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 8991 NSUInteger count = _dictionary.count; 8992 if (count == 0) { 8993 return 0; 8994 } 8995 8996 GPBDataType valueDataType = GPBGetFieldDataType(field); 8997 GPBDataType keyDataType = field.mapKeyDataType; 8998 __block size_t result = 0; 8999 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 9000 NSNumber *aValue, 9001 BOOL *stop) { 9002 #pragma unused(stop) 9003 size_t msgSize = ComputeDictInt64FieldSize([aKey longLongValue], kMapKeyFieldNumber, keyDataType); 9004 msgSize += ComputeDictEnumFieldSize([aValue intValue], kMapValueFieldNumber, valueDataType); 9005 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 9006 }]; 9007 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 9008 result += tagSize * count; 9009 return result; 9010 } 9011 9012 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 9013 asField:(GPBFieldDescriptor *)field { 9014 GPBDataType valueDataType = GPBGetFieldDataType(field); 9015 GPBDataType keyDataType = field.mapKeyDataType; 9016 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 9017 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 9018 NSNumber *aValue, 9019 BOOL *stop) { 9020 #pragma unused(stop) 9021 // Write the tag. 9022 [outputStream writeInt32NoTag:tag]; 9023 // Write the size of the message. 9024 size_t msgSize = ComputeDictInt64FieldSize([aKey longLongValue], kMapKeyFieldNumber, keyDataType); 9025 msgSize += ComputeDictEnumFieldSize([aValue intValue], kMapValueFieldNumber, valueDataType); 9026 [outputStream writeInt32NoTag:(int32_t)msgSize]; 9027 // Write the fields. 9028 WriteDictInt64Field(outputStream, [aKey longLongValue], kMapKeyFieldNumber, keyDataType); 9029 WriteDictEnumField(outputStream, [aValue intValue], kMapValueFieldNumber, valueDataType); 9030 }]; 9031 } 9032 9033 - (NSData *)serializedDataForUnknownValue:(int32_t)value 9034 forKey:(GPBGenericValue *)key 9035 keyDataType:(GPBDataType)keyDataType { 9036 size_t msgSize = ComputeDictInt64FieldSize(key->valueInt64, kMapKeyFieldNumber, keyDataType); 9037 msgSize += ComputeDictEnumFieldSize(value, kMapValueFieldNumber, GPBDataTypeEnum); 9038 NSMutableData *data = [NSMutableData dataWithLength:msgSize]; 9039 GPBCodedOutputStream *outputStream = [[GPBCodedOutputStream alloc] initWithData:data]; 9040 WriteDictInt64Field(outputStream, key->valueInt64, kMapKeyFieldNumber, keyDataType); 9041 WriteDictEnumField(outputStream, value, kMapValueFieldNumber, GPBDataTypeEnum); 9042 [outputStream release]; 9043 return data; 9044 } 9045 - (void)setGPBGenericValue:(GPBGenericValue *)value 9046 forGPBGenericValueKey:(GPBGenericValue *)key { 9047 [_dictionary setObject:@(value->valueEnum) forKey:@(key->valueInt64)]; 9048 } 9049 9050 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 9051 [self enumerateKeysAndRawValuesUsingBlock:^(int64_t key, int32_t value, BOOL *stop) { 9052 #pragma unused(stop) 9053 block([NSString stringWithFormat:@"%lld", key], @(value)); 9054 }]; 9055 } 9056 9057 - (BOOL)valueForKey:(int64_t)key value:(int32_t *)value { 9058 NSNumber *wrapped = [_dictionary objectForKey:@(key)]; 9059 if (wrapped && value) { 9060 int32_t result = [wrapped intValue]; 9061 if (!_validationFunc(result)) { 9062 result = kGPBUnrecognizedEnumeratorValue; 9063 } 9064 *value = result; 9065 } 9066 return (wrapped != NULL); 9067 } 9068 9069 - (BOOL)valueForKey:(int64_t)key rawValue:(int32_t *)rawValue { 9070 NSNumber *wrapped = [_dictionary objectForKey:@(key)]; 9071 if (wrapped && rawValue) { 9072 *rawValue = [wrapped intValue]; 9073 } 9074 return (wrapped != NULL); 9075 } 9076 9077 - (void)enumerateKeysAndValuesUsingBlock: 9078 (void (^)(int64_t key, int32_t value, BOOL *stop))block { 9079 GPBEnumValidationFunc func = _validationFunc; 9080 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 9081 NSNumber *aValue, 9082 BOOL *stop) { 9083 int32_t unwrapped = [aValue intValue]; 9084 if (!func(unwrapped)) { 9085 unwrapped = kGPBUnrecognizedEnumeratorValue; 9086 } 9087 block([aKey longLongValue], unwrapped, stop); 9088 }]; 9089 } 9090 9091 - (void)addRawEntriesFromDictionary:(GPBInt64EnumDictionary *)otherDictionary { 9092 if (otherDictionary) { 9093 [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 9094 if (_autocreator) { 9095 GPBAutocreatedDictionaryModified(_autocreator, self); 9096 } 9097 } 9098 } 9099 9100 - (void)setRawValue:(int32_t)value forKey:(int64_t)key { 9101 [_dictionary setObject:@(value) forKey:@(key)]; 9102 if (_autocreator) { 9103 GPBAutocreatedDictionaryModified(_autocreator, self); 9104 } 9105 } 9106 9107 - (void)removeValueForKey:(int64_t)aKey { 9108 [_dictionary removeObjectForKey:@(aKey)]; 9109 } 9110 9111 - (void)removeAll { 9112 [_dictionary removeAllObjects]; 9113 } 9114 9115 - (void)setValue:(int32_t)value forKey:(int64_t)key { 9116 if (!_validationFunc(value)) { 9117 [NSException raise:NSInvalidArgumentException 9118 format:@"GPBInt64EnumDictionary: Attempt to set an unknown enum value (%d)", 9119 value]; 9120 } 9121 9122 [_dictionary setObject:@(value) forKey:@(key)]; 9123 if (_autocreator) { 9124 GPBAutocreatedDictionaryModified(_autocreator, self); 9125 } 9126 } 9127 9128 @end 9129 9130 #pragma mark - Int64 -> Object 9131 9132 @implementation GPBInt64ObjectDictionary { 9133 @package 9134 NSMutableDictionary *_dictionary; 9135 } 9136 9137 + (instancetype)dictionary { 9138 return [[[self alloc] initWithObjects:NULL forKeys:NULL count:0] autorelease]; 9139 } 9140 9141 + (instancetype)dictionaryWithObject:(id)object 9142 forKey:(int64_t)key { 9143 // Cast is needed so the compiler knows what class we are invoking initWithObjects:forKeys:count: 9144 // on to get the type correct. 9145 return [[(GPBInt64ObjectDictionary*)[self alloc] initWithObjects:&object 9146 forKeys:&key 9147 count:1] autorelease]; 9148 } 9149 9150 + (instancetype)dictionaryWithObjects:(const id [])objects 9151 forKeys:(const int64_t [])keys 9152 count:(NSUInteger)count { 9153 // Cast is needed so the compiler knows what class we are invoking initWithObjects:forKeys:count: 9154 // on to get the type correct. 9155 return [[(GPBInt64ObjectDictionary*)[self alloc] initWithObjects:objects 9156 forKeys:keys 9157 count:count] autorelease]; 9158 } 9159 9160 + (instancetype)dictionaryWithDictionary:(GPBInt64ObjectDictionary *)dictionary { 9161 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 9162 // on to get the type correct. 9163 return [[(GPBInt64ObjectDictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 9164 } 9165 9166 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 9167 return [[[self alloc] initWithCapacity:numItems] autorelease]; 9168 } 9169 9170 - (instancetype)init { 9171 return [self initWithObjects:NULL forKeys:NULL count:0]; 9172 } 9173 9174 - (instancetype)initWithObjects:(const id [])objects 9175 forKeys:(const int64_t [])keys 9176 count:(NSUInteger)count { 9177 self = [super init]; 9178 if (self) { 9179 _dictionary = [[NSMutableDictionary alloc] init]; 9180 if (count && objects && keys) { 9181 for (NSUInteger i = 0; i < count; ++i) { 9182 if (!objects[i]) { 9183 [NSException raise:NSInvalidArgumentException 9184 format:@"Attempting to add nil object to a Dictionary"]; 9185 } 9186 [_dictionary setObject:objects[i] forKey:@(keys[i])]; 9187 } 9188 } 9189 } 9190 return self; 9191 } 9192 9193 - (instancetype)initWithDictionary:(GPBInt64ObjectDictionary *)dictionary { 9194 self = [self initWithObjects:NULL forKeys:NULL count:0]; 9195 if (self) { 9196 if (dictionary) { 9197 [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 9198 } 9199 } 9200 return self; 9201 } 9202 9203 - (instancetype)initWithCapacity:(NSUInteger)numItems { 9204 #pragma unused(numItems) 9205 return [self initWithObjects:NULL forKeys:NULL count:0]; 9206 } 9207 9208 - (void)dealloc { 9209 NSAssert(!_autocreator, 9210 @"%@: Autocreator must be cleared before release, autocreator: %@", 9211 [self class], _autocreator); 9212 [_dictionary release]; 9213 [super dealloc]; 9214 } 9215 9216 - (instancetype)copyWithZone:(NSZone *)zone { 9217 return [[GPBInt64ObjectDictionary allocWithZone:zone] initWithDictionary:self]; 9218 } 9219 9220 - (BOOL)isEqual:(GPBInt64ObjectDictionary *)other { 9221 if (self == other) { 9222 return YES; 9223 } 9224 if (![other isKindOfClass:[GPBInt64ObjectDictionary class]]) { 9225 return NO; 9226 } 9227 return [_dictionary isEqual:other->_dictionary]; 9228 } 9229 9230 - (NSUInteger)hash { 9231 return _dictionary.count; 9232 } 9233 9234 - (NSString *)description { 9235 return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 9236 } 9237 9238 - (NSUInteger)count { 9239 return _dictionary.count; 9240 } 9241 9242 - (void)enumerateKeysAndObjectsUsingBlock: 9243 (void (^)(int64_t key, id object, BOOL *stop))block { 9244 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 9245 id aObject, 9246 BOOL *stop) { 9247 block([aKey longLongValue], aObject, stop); 9248 }]; 9249 } 9250 9251 - (BOOL)isInitialized { 9252 for (GPBMessage *msg in [_dictionary objectEnumerator]) { 9253 if (!msg.initialized) { 9254 return NO; 9255 } 9256 } 9257 return YES; 9258 } 9259 9260 - (instancetype)deepCopyWithZone:(NSZone *)zone { 9261 GPBInt64ObjectDictionary *newDict = 9262 [[GPBInt64ObjectDictionary alloc] init]; 9263 [_dictionary enumerateKeysAndObjectsUsingBlock:^(id aKey, 9264 GPBMessage *msg, 9265 BOOL *stop) { 9266 #pragma unused(stop) 9267 GPBMessage *copiedMsg = [msg copyWithZone:zone]; 9268 [newDict->_dictionary setObject:copiedMsg forKey:aKey]; 9269 [copiedMsg release]; 9270 }]; 9271 return newDict; 9272 } 9273 9274 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 9275 NSUInteger count = _dictionary.count; 9276 if (count == 0) { 9277 return 0; 9278 } 9279 9280 GPBDataType valueDataType = GPBGetFieldDataType(field); 9281 GPBDataType keyDataType = field.mapKeyDataType; 9282 __block size_t result = 0; 9283 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 9284 id aObject, 9285 BOOL *stop) { 9286 #pragma unused(stop) 9287 size_t msgSize = ComputeDictInt64FieldSize([aKey longLongValue], kMapKeyFieldNumber, keyDataType); 9288 msgSize += ComputeDictObjectFieldSize(aObject, kMapValueFieldNumber, valueDataType); 9289 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 9290 }]; 9291 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 9292 result += tagSize * count; 9293 return result; 9294 } 9295 9296 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 9297 asField:(GPBFieldDescriptor *)field { 9298 GPBDataType valueDataType = GPBGetFieldDataType(field); 9299 GPBDataType keyDataType = field.mapKeyDataType; 9300 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 9301 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, 9302 id aObject, 9303 BOOL *stop) { 9304 #pragma unused(stop) 9305 // Write the tag. 9306 [outputStream writeInt32NoTag:tag]; 9307 // Write the size of the message. 9308 size_t msgSize = ComputeDictInt64FieldSize([aKey longLongValue], kMapKeyFieldNumber, keyDataType); 9309 msgSize += ComputeDictObjectFieldSize(aObject, kMapValueFieldNumber, valueDataType); 9310 [outputStream writeInt32NoTag:(int32_t)msgSize]; 9311 // Write the fields. 9312 WriteDictInt64Field(outputStream, [aKey longLongValue], kMapKeyFieldNumber, keyDataType); 9313 WriteDictObjectField(outputStream, aObject, kMapValueFieldNumber, valueDataType); 9314 }]; 9315 } 9316 9317 - (void)setGPBGenericValue:(GPBGenericValue *)value 9318 forGPBGenericValueKey:(GPBGenericValue *)key { 9319 [_dictionary setObject:value->valueString forKey:@(key->valueInt64)]; 9320 } 9321 9322 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 9323 [self enumerateKeysAndObjectsUsingBlock:^(int64_t key, id object, BOOL *stop) { 9324 #pragma unused(stop) 9325 block([NSString stringWithFormat:@"%lld", key], object); 9326 }]; 9327 } 9328 9329 - (id)objectForKey:(int64_t)key { 9330 id result = [_dictionary objectForKey:@(key)]; 9331 return result; 9332 } 9333 9334 - (void)addEntriesFromDictionary:(GPBInt64ObjectDictionary *)otherDictionary { 9335 if (otherDictionary) { 9336 [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 9337 if (_autocreator) { 9338 GPBAutocreatedDictionaryModified(_autocreator, self); 9339 } 9340 } 9341 } 9342 9343 - (void)setObject:(id)object forKey:(int64_t)key { 9344 if (!object) { 9345 [NSException raise:NSInvalidArgumentException 9346 format:@"Attempting to add nil object to a Dictionary"]; 9347 } 9348 [_dictionary setObject:object forKey:@(key)]; 9349 if (_autocreator) { 9350 GPBAutocreatedDictionaryModified(_autocreator, self); 9351 } 9352 } 9353 9354 - (void)removeObjectForKey:(int64_t)aKey { 9355 [_dictionary removeObjectForKey:@(aKey)]; 9356 } 9357 9358 - (void)removeAll { 9359 [_dictionary removeAllObjects]; 9360 } 9361 9362 @end 9363 9364 //%PDDM-EXPAND DICTIONARY_POD_IMPL_FOR_KEY(String, NSString, *, OBJECT) 9365 // This block of code is generated, do not edit it directly. 9366 9367 #pragma mark - String -> UInt32 9368 9369 @implementation GPBStringUInt32Dictionary { 9370 @package 9371 NSMutableDictionary *_dictionary; 9372 } 9373 9374 + (instancetype)dictionary { 9375 return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; 9376 } 9377 9378 + (instancetype)dictionaryWithValue:(uint32_t)value 9379 forKey:(NSString *)key { 9380 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 9381 // on to get the type correct. 9382 return [[(GPBStringUInt32Dictionary*)[self alloc] initWithValues:&value 9383 forKeys:&key 9384 count:1] autorelease]; 9385 } 9386 9387 + (instancetype)dictionaryWithValues:(const uint32_t [])values 9388 forKeys:(const NSString * [])keys 9389 count:(NSUInteger)count { 9390 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 9391 // on to get the type correct. 9392 return [[(GPBStringUInt32Dictionary*)[self alloc] initWithValues:values 9393 forKeys:keys 9394 count:count] autorelease]; 9395 } 9396 9397 + (instancetype)dictionaryWithDictionary:(GPBStringUInt32Dictionary *)dictionary { 9398 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 9399 // on to get the type correct. 9400 return [[(GPBStringUInt32Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 9401 } 9402 9403 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 9404 return [[[self alloc] initWithCapacity:numItems] autorelease]; 9405 } 9406 9407 - (instancetype)init { 9408 return [self initWithValues:NULL forKeys:NULL count:0]; 9409 } 9410 9411 - (instancetype)initWithValues:(const uint32_t [])values 9412 forKeys:(const NSString * [])keys 9413 count:(NSUInteger)count { 9414 self = [super init]; 9415 if (self) { 9416 _dictionary = [[NSMutableDictionary alloc] init]; 9417 if (count && values && keys) { 9418 for (NSUInteger i = 0; i < count; ++i) { 9419 if (!keys[i]) { 9420 [NSException raise:NSInvalidArgumentException 9421 format:@"Attempting to add nil key to a Dictionary"]; 9422 } 9423 [_dictionary setObject:@(values[i]) forKey:keys[i]]; 9424 } 9425 } 9426 } 9427 return self; 9428 } 9429 9430 - (instancetype)initWithDictionary:(GPBStringUInt32Dictionary *)dictionary { 9431 self = [self initWithValues:NULL forKeys:NULL count:0]; 9432 if (self) { 9433 if (dictionary) { 9434 [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 9435 } 9436 } 9437 return self; 9438 } 9439 9440 - (instancetype)initWithCapacity:(NSUInteger)numItems { 9441 #pragma unused(numItems) 9442 return [self initWithValues:NULL forKeys:NULL count:0]; 9443 } 9444 9445 - (void)dealloc { 9446 NSAssert(!_autocreator, 9447 @"%@: Autocreator must be cleared before release, autocreator: %@", 9448 [self class], _autocreator); 9449 [_dictionary release]; 9450 [super dealloc]; 9451 } 9452 9453 - (instancetype)copyWithZone:(NSZone *)zone { 9454 return [[GPBStringUInt32Dictionary allocWithZone:zone] initWithDictionary:self]; 9455 } 9456 9457 - (BOOL)isEqual:(GPBStringUInt32Dictionary *)other { 9458 if (self == other) { 9459 return YES; 9460 } 9461 if (![other isKindOfClass:[GPBStringUInt32Dictionary class]]) { 9462 return NO; 9463 } 9464 return [_dictionary isEqual:other->_dictionary]; 9465 } 9466 9467 - (NSUInteger)hash { 9468 return _dictionary.count; 9469 } 9470 9471 - (NSString *)description { 9472 return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 9473 } 9474 9475 - (NSUInteger)count { 9476 return _dictionary.count; 9477 } 9478 9479 - (void)enumerateKeysAndValuesUsingBlock: 9480 (void (^)(NSString *key, uint32_t value, BOOL *stop))block { 9481 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSString *aKey, 9482 NSNumber *aValue, 9483 BOOL *stop) { 9484 block(aKey, [aValue unsignedIntValue], stop); 9485 }]; 9486 } 9487 9488 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 9489 NSUInteger count = _dictionary.count; 9490 if (count == 0) { 9491 return 0; 9492 } 9493 9494 GPBDataType valueDataType = GPBGetFieldDataType(field); 9495 GPBDataType keyDataType = field.mapKeyDataType; 9496 __block size_t result = 0; 9497 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSString *aKey, 9498 NSNumber *aValue, 9499 BOOL *stop) { 9500 #pragma unused(stop) 9501 size_t msgSize = ComputeDictStringFieldSize(aKey, kMapKeyFieldNumber, keyDataType); 9502 msgSize += ComputeDictUInt32FieldSize([aValue unsignedIntValue], kMapValueFieldNumber, valueDataType); 9503 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 9504 }]; 9505 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 9506 result += tagSize * count; 9507 return result; 9508 } 9509 9510 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 9511 asField:(GPBFieldDescriptor *)field { 9512 GPBDataType valueDataType = GPBGetFieldDataType(field); 9513 GPBDataType keyDataType = field.mapKeyDataType; 9514 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 9515 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSString *aKey, 9516 NSNumber *aValue, 9517 BOOL *stop) { 9518 #pragma unused(stop) 9519 // Write the tag. 9520 [outputStream writeInt32NoTag:tag]; 9521 // Write the size of the message. 9522 size_t msgSize = ComputeDictStringFieldSize(aKey, kMapKeyFieldNumber, keyDataType); 9523 msgSize += ComputeDictUInt32FieldSize([aValue unsignedIntValue], kMapValueFieldNumber, valueDataType); 9524 [outputStream writeInt32NoTag:(int32_t)msgSize]; 9525 // Write the fields. 9526 WriteDictStringField(outputStream, aKey, kMapKeyFieldNumber, keyDataType); 9527 WriteDictUInt32Field(outputStream, [aValue unsignedIntValue], kMapValueFieldNumber, valueDataType); 9528 }]; 9529 } 9530 9531 - (void)setGPBGenericValue:(GPBGenericValue *)value 9532 forGPBGenericValueKey:(GPBGenericValue *)key { 9533 [_dictionary setObject:@(value->valueUInt32) forKey:key->valueString]; 9534 } 9535 9536 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 9537 [self enumerateKeysAndValuesUsingBlock:^(NSString *key, uint32_t value, BOOL *stop) { 9538 #pragma unused(stop) 9539 block(key, [NSString stringWithFormat:@"%u", value]); 9540 }]; 9541 } 9542 9543 - (BOOL)valueForKey:(NSString *)key value:(uint32_t *)value { 9544 NSNumber *wrapped = [_dictionary objectForKey:key]; 9545 if (wrapped && value) { 9546 *value = [wrapped unsignedIntValue]; 9547 } 9548 return (wrapped != NULL); 9549 } 9550 9551 - (void)addEntriesFromDictionary:(GPBStringUInt32Dictionary *)otherDictionary { 9552 if (otherDictionary) { 9553 [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 9554 if (_autocreator) { 9555 GPBAutocreatedDictionaryModified(_autocreator, self); 9556 } 9557 } 9558 } 9559 9560 - (void)setValue:(uint32_t)value forKey:(NSString *)key { 9561 if (!key) { 9562 [NSException raise:NSInvalidArgumentException 9563 format:@"Attempting to add nil key to a Dictionary"]; 9564 } 9565 [_dictionary setObject:@(value) forKey:key]; 9566 if (_autocreator) { 9567 GPBAutocreatedDictionaryModified(_autocreator, self); 9568 } 9569 } 9570 9571 - (void)removeValueForKey:(NSString *)aKey { 9572 [_dictionary removeObjectForKey:aKey]; 9573 } 9574 9575 - (void)removeAll { 9576 [_dictionary removeAllObjects]; 9577 } 9578 9579 @end 9580 9581 #pragma mark - String -> Int32 9582 9583 @implementation GPBStringInt32Dictionary { 9584 @package 9585 NSMutableDictionary *_dictionary; 9586 } 9587 9588 + (instancetype)dictionary { 9589 return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; 9590 } 9591 9592 + (instancetype)dictionaryWithValue:(int32_t)value 9593 forKey:(NSString *)key { 9594 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 9595 // on to get the type correct. 9596 return [[(GPBStringInt32Dictionary*)[self alloc] initWithValues:&value 9597 forKeys:&key 9598 count:1] autorelease]; 9599 } 9600 9601 + (instancetype)dictionaryWithValues:(const int32_t [])values 9602 forKeys:(const NSString * [])keys 9603 count:(NSUInteger)count { 9604 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 9605 // on to get the type correct. 9606 return [[(GPBStringInt32Dictionary*)[self alloc] initWithValues:values 9607 forKeys:keys 9608 count:count] autorelease]; 9609 } 9610 9611 + (instancetype)dictionaryWithDictionary:(GPBStringInt32Dictionary *)dictionary { 9612 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 9613 // on to get the type correct. 9614 return [[(GPBStringInt32Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 9615 } 9616 9617 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 9618 return [[[self alloc] initWithCapacity:numItems] autorelease]; 9619 } 9620 9621 - (instancetype)init { 9622 return [self initWithValues:NULL forKeys:NULL count:0]; 9623 } 9624 9625 - (instancetype)initWithValues:(const int32_t [])values 9626 forKeys:(const NSString * [])keys 9627 count:(NSUInteger)count { 9628 self = [super init]; 9629 if (self) { 9630 _dictionary = [[NSMutableDictionary alloc] init]; 9631 if (count && values && keys) { 9632 for (NSUInteger i = 0; i < count; ++i) { 9633 if (!keys[i]) { 9634 [NSException raise:NSInvalidArgumentException 9635 format:@"Attempting to add nil key to a Dictionary"]; 9636 } 9637 [_dictionary setObject:@(values[i]) forKey:keys[i]]; 9638 } 9639 } 9640 } 9641 return self; 9642 } 9643 9644 - (instancetype)initWithDictionary:(GPBStringInt32Dictionary *)dictionary { 9645 self = [self initWithValues:NULL forKeys:NULL count:0]; 9646 if (self) { 9647 if (dictionary) { 9648 [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 9649 } 9650 } 9651 return self; 9652 } 9653 9654 - (instancetype)initWithCapacity:(NSUInteger)numItems { 9655 #pragma unused(numItems) 9656 return [self initWithValues:NULL forKeys:NULL count:0]; 9657 } 9658 9659 - (void)dealloc { 9660 NSAssert(!_autocreator, 9661 @"%@: Autocreator must be cleared before release, autocreator: %@", 9662 [self class], _autocreator); 9663 [_dictionary release]; 9664 [super dealloc]; 9665 } 9666 9667 - (instancetype)copyWithZone:(NSZone *)zone { 9668 return [[GPBStringInt32Dictionary allocWithZone:zone] initWithDictionary:self]; 9669 } 9670 9671 - (BOOL)isEqual:(GPBStringInt32Dictionary *)other { 9672 if (self == other) { 9673 return YES; 9674 } 9675 if (![other isKindOfClass:[GPBStringInt32Dictionary class]]) { 9676 return NO; 9677 } 9678 return [_dictionary isEqual:other->_dictionary]; 9679 } 9680 9681 - (NSUInteger)hash { 9682 return _dictionary.count; 9683 } 9684 9685 - (NSString *)description { 9686 return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 9687 } 9688 9689 - (NSUInteger)count { 9690 return _dictionary.count; 9691 } 9692 9693 - (void)enumerateKeysAndValuesUsingBlock: 9694 (void (^)(NSString *key, int32_t value, BOOL *stop))block { 9695 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSString *aKey, 9696 NSNumber *aValue, 9697 BOOL *stop) { 9698 block(aKey, [aValue intValue], stop); 9699 }]; 9700 } 9701 9702 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 9703 NSUInteger count = _dictionary.count; 9704 if (count == 0) { 9705 return 0; 9706 } 9707 9708 GPBDataType valueDataType = GPBGetFieldDataType(field); 9709 GPBDataType keyDataType = field.mapKeyDataType; 9710 __block size_t result = 0; 9711 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSString *aKey, 9712 NSNumber *aValue, 9713 BOOL *stop) { 9714 #pragma unused(stop) 9715 size_t msgSize = ComputeDictStringFieldSize(aKey, kMapKeyFieldNumber, keyDataType); 9716 msgSize += ComputeDictInt32FieldSize([aValue intValue], kMapValueFieldNumber, valueDataType); 9717 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 9718 }]; 9719 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 9720 result += tagSize * count; 9721 return result; 9722 } 9723 9724 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 9725 asField:(GPBFieldDescriptor *)field { 9726 GPBDataType valueDataType = GPBGetFieldDataType(field); 9727 GPBDataType keyDataType = field.mapKeyDataType; 9728 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 9729 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSString *aKey, 9730 NSNumber *aValue, 9731 BOOL *stop) { 9732 #pragma unused(stop) 9733 // Write the tag. 9734 [outputStream writeInt32NoTag:tag]; 9735 // Write the size of the message. 9736 size_t msgSize = ComputeDictStringFieldSize(aKey, kMapKeyFieldNumber, keyDataType); 9737 msgSize += ComputeDictInt32FieldSize([aValue intValue], kMapValueFieldNumber, valueDataType); 9738 [outputStream writeInt32NoTag:(int32_t)msgSize]; 9739 // Write the fields. 9740 WriteDictStringField(outputStream, aKey, kMapKeyFieldNumber, keyDataType); 9741 WriteDictInt32Field(outputStream, [aValue intValue], kMapValueFieldNumber, valueDataType); 9742 }]; 9743 } 9744 9745 - (void)setGPBGenericValue:(GPBGenericValue *)value 9746 forGPBGenericValueKey:(GPBGenericValue *)key { 9747 [_dictionary setObject:@(value->valueInt32) forKey:key->valueString]; 9748 } 9749 9750 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 9751 [self enumerateKeysAndValuesUsingBlock:^(NSString *key, int32_t value, BOOL *stop) { 9752 #pragma unused(stop) 9753 block(key, [NSString stringWithFormat:@"%d", value]); 9754 }]; 9755 } 9756 9757 - (BOOL)valueForKey:(NSString *)key value:(int32_t *)value { 9758 NSNumber *wrapped = [_dictionary objectForKey:key]; 9759 if (wrapped && value) { 9760 *value = [wrapped intValue]; 9761 } 9762 return (wrapped != NULL); 9763 } 9764 9765 - (void)addEntriesFromDictionary:(GPBStringInt32Dictionary *)otherDictionary { 9766 if (otherDictionary) { 9767 [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 9768 if (_autocreator) { 9769 GPBAutocreatedDictionaryModified(_autocreator, self); 9770 } 9771 } 9772 } 9773 9774 - (void)setValue:(int32_t)value forKey:(NSString *)key { 9775 if (!key) { 9776 [NSException raise:NSInvalidArgumentException 9777 format:@"Attempting to add nil key to a Dictionary"]; 9778 } 9779 [_dictionary setObject:@(value) forKey:key]; 9780 if (_autocreator) { 9781 GPBAutocreatedDictionaryModified(_autocreator, self); 9782 } 9783 } 9784 9785 - (void)removeValueForKey:(NSString *)aKey { 9786 [_dictionary removeObjectForKey:aKey]; 9787 } 9788 9789 - (void)removeAll { 9790 [_dictionary removeAllObjects]; 9791 } 9792 9793 @end 9794 9795 #pragma mark - String -> UInt64 9796 9797 @implementation GPBStringUInt64Dictionary { 9798 @package 9799 NSMutableDictionary *_dictionary; 9800 } 9801 9802 + (instancetype)dictionary { 9803 return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; 9804 } 9805 9806 + (instancetype)dictionaryWithValue:(uint64_t)value 9807 forKey:(NSString *)key { 9808 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 9809 // on to get the type correct. 9810 return [[(GPBStringUInt64Dictionary*)[self alloc] initWithValues:&value 9811 forKeys:&key 9812 count:1] autorelease]; 9813 } 9814 9815 + (instancetype)dictionaryWithValues:(const uint64_t [])values 9816 forKeys:(const NSString * [])keys 9817 count:(NSUInteger)count { 9818 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 9819 // on to get the type correct. 9820 return [[(GPBStringUInt64Dictionary*)[self alloc] initWithValues:values 9821 forKeys:keys 9822 count:count] autorelease]; 9823 } 9824 9825 + (instancetype)dictionaryWithDictionary:(GPBStringUInt64Dictionary *)dictionary { 9826 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 9827 // on to get the type correct. 9828 return [[(GPBStringUInt64Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 9829 } 9830 9831 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 9832 return [[[self alloc] initWithCapacity:numItems] autorelease]; 9833 } 9834 9835 - (instancetype)init { 9836 return [self initWithValues:NULL forKeys:NULL count:0]; 9837 } 9838 9839 - (instancetype)initWithValues:(const uint64_t [])values 9840 forKeys:(const NSString * [])keys 9841 count:(NSUInteger)count { 9842 self = [super init]; 9843 if (self) { 9844 _dictionary = [[NSMutableDictionary alloc] init]; 9845 if (count && values && keys) { 9846 for (NSUInteger i = 0; i < count; ++i) { 9847 if (!keys[i]) { 9848 [NSException raise:NSInvalidArgumentException 9849 format:@"Attempting to add nil key to a Dictionary"]; 9850 } 9851 [_dictionary setObject:@(values[i]) forKey:keys[i]]; 9852 } 9853 } 9854 } 9855 return self; 9856 } 9857 9858 - (instancetype)initWithDictionary:(GPBStringUInt64Dictionary *)dictionary { 9859 self = [self initWithValues:NULL forKeys:NULL count:0]; 9860 if (self) { 9861 if (dictionary) { 9862 [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 9863 } 9864 } 9865 return self; 9866 } 9867 9868 - (instancetype)initWithCapacity:(NSUInteger)numItems { 9869 #pragma unused(numItems) 9870 return [self initWithValues:NULL forKeys:NULL count:0]; 9871 } 9872 9873 - (void)dealloc { 9874 NSAssert(!_autocreator, 9875 @"%@: Autocreator must be cleared before release, autocreator: %@", 9876 [self class], _autocreator); 9877 [_dictionary release]; 9878 [super dealloc]; 9879 } 9880 9881 - (instancetype)copyWithZone:(NSZone *)zone { 9882 return [[GPBStringUInt64Dictionary allocWithZone:zone] initWithDictionary:self]; 9883 } 9884 9885 - (BOOL)isEqual:(GPBStringUInt64Dictionary *)other { 9886 if (self == other) { 9887 return YES; 9888 } 9889 if (![other isKindOfClass:[GPBStringUInt64Dictionary class]]) { 9890 return NO; 9891 } 9892 return [_dictionary isEqual:other->_dictionary]; 9893 } 9894 9895 - (NSUInteger)hash { 9896 return _dictionary.count; 9897 } 9898 9899 - (NSString *)description { 9900 return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 9901 } 9902 9903 - (NSUInteger)count { 9904 return _dictionary.count; 9905 } 9906 9907 - (void)enumerateKeysAndValuesUsingBlock: 9908 (void (^)(NSString *key, uint64_t value, BOOL *stop))block { 9909 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSString *aKey, 9910 NSNumber *aValue, 9911 BOOL *stop) { 9912 block(aKey, [aValue unsignedLongLongValue], stop); 9913 }]; 9914 } 9915 9916 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 9917 NSUInteger count = _dictionary.count; 9918 if (count == 0) { 9919 return 0; 9920 } 9921 9922 GPBDataType valueDataType = GPBGetFieldDataType(field); 9923 GPBDataType keyDataType = field.mapKeyDataType; 9924 __block size_t result = 0; 9925 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSString *aKey, 9926 NSNumber *aValue, 9927 BOOL *stop) { 9928 #pragma unused(stop) 9929 size_t msgSize = ComputeDictStringFieldSize(aKey, kMapKeyFieldNumber, keyDataType); 9930 msgSize += ComputeDictUInt64FieldSize([aValue unsignedLongLongValue], kMapValueFieldNumber, valueDataType); 9931 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 9932 }]; 9933 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 9934 result += tagSize * count; 9935 return result; 9936 } 9937 9938 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 9939 asField:(GPBFieldDescriptor *)field { 9940 GPBDataType valueDataType = GPBGetFieldDataType(field); 9941 GPBDataType keyDataType = field.mapKeyDataType; 9942 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 9943 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSString *aKey, 9944 NSNumber *aValue, 9945 BOOL *stop) { 9946 #pragma unused(stop) 9947 // Write the tag. 9948 [outputStream writeInt32NoTag:tag]; 9949 // Write the size of the message. 9950 size_t msgSize = ComputeDictStringFieldSize(aKey, kMapKeyFieldNumber, keyDataType); 9951 msgSize += ComputeDictUInt64FieldSize([aValue unsignedLongLongValue], kMapValueFieldNumber, valueDataType); 9952 [outputStream writeInt32NoTag:(int32_t)msgSize]; 9953 // Write the fields. 9954 WriteDictStringField(outputStream, aKey, kMapKeyFieldNumber, keyDataType); 9955 WriteDictUInt64Field(outputStream, [aValue unsignedLongLongValue], kMapValueFieldNumber, valueDataType); 9956 }]; 9957 } 9958 9959 - (void)setGPBGenericValue:(GPBGenericValue *)value 9960 forGPBGenericValueKey:(GPBGenericValue *)key { 9961 [_dictionary setObject:@(value->valueUInt64) forKey:key->valueString]; 9962 } 9963 9964 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 9965 [self enumerateKeysAndValuesUsingBlock:^(NSString *key, uint64_t value, BOOL *stop) { 9966 #pragma unused(stop) 9967 block(key, [NSString stringWithFormat:@"%llu", value]); 9968 }]; 9969 } 9970 9971 - (BOOL)valueForKey:(NSString *)key value:(uint64_t *)value { 9972 NSNumber *wrapped = [_dictionary objectForKey:key]; 9973 if (wrapped && value) { 9974 *value = [wrapped unsignedLongLongValue]; 9975 } 9976 return (wrapped != NULL); 9977 } 9978 9979 - (void)addEntriesFromDictionary:(GPBStringUInt64Dictionary *)otherDictionary { 9980 if (otherDictionary) { 9981 [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 9982 if (_autocreator) { 9983 GPBAutocreatedDictionaryModified(_autocreator, self); 9984 } 9985 } 9986 } 9987 9988 - (void)setValue:(uint64_t)value forKey:(NSString *)key { 9989 if (!key) { 9990 [NSException raise:NSInvalidArgumentException 9991 format:@"Attempting to add nil key to a Dictionary"]; 9992 } 9993 [_dictionary setObject:@(value) forKey:key]; 9994 if (_autocreator) { 9995 GPBAutocreatedDictionaryModified(_autocreator, self); 9996 } 9997 } 9998 9999 - (void)removeValueForKey:(NSString *)aKey { 10000 [_dictionary removeObjectForKey:aKey]; 10001 } 10002 10003 - (void)removeAll { 10004 [_dictionary removeAllObjects]; 10005 } 10006 10007 @end 10008 10009 #pragma mark - String -> Int64 10010 10011 @implementation GPBStringInt64Dictionary { 10012 @package 10013 NSMutableDictionary *_dictionary; 10014 } 10015 10016 + (instancetype)dictionary { 10017 return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; 10018 } 10019 10020 + (instancetype)dictionaryWithValue:(int64_t)value 10021 forKey:(NSString *)key { 10022 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 10023 // on to get the type correct. 10024 return [[(GPBStringInt64Dictionary*)[self alloc] initWithValues:&value 10025 forKeys:&key 10026 count:1] autorelease]; 10027 } 10028 10029 + (instancetype)dictionaryWithValues:(const int64_t [])values 10030 forKeys:(const NSString * [])keys 10031 count:(NSUInteger)count { 10032 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 10033 // on to get the type correct. 10034 return [[(GPBStringInt64Dictionary*)[self alloc] initWithValues:values 10035 forKeys:keys 10036 count:count] autorelease]; 10037 } 10038 10039 + (instancetype)dictionaryWithDictionary:(GPBStringInt64Dictionary *)dictionary { 10040 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 10041 // on to get the type correct. 10042 return [[(GPBStringInt64Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 10043 } 10044 10045 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 10046 return [[[self alloc] initWithCapacity:numItems] autorelease]; 10047 } 10048 10049 - (instancetype)init { 10050 return [self initWithValues:NULL forKeys:NULL count:0]; 10051 } 10052 10053 - (instancetype)initWithValues:(const int64_t [])values 10054 forKeys:(const NSString * [])keys 10055 count:(NSUInteger)count { 10056 self = [super init]; 10057 if (self) { 10058 _dictionary = [[NSMutableDictionary alloc] init]; 10059 if (count && values && keys) { 10060 for (NSUInteger i = 0; i < count; ++i) { 10061 if (!keys[i]) { 10062 [NSException raise:NSInvalidArgumentException 10063 format:@"Attempting to add nil key to a Dictionary"]; 10064 } 10065 [_dictionary setObject:@(values[i]) forKey:keys[i]]; 10066 } 10067 } 10068 } 10069 return self; 10070 } 10071 10072 - (instancetype)initWithDictionary:(GPBStringInt64Dictionary *)dictionary { 10073 self = [self initWithValues:NULL forKeys:NULL count:0]; 10074 if (self) { 10075 if (dictionary) { 10076 [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 10077 } 10078 } 10079 return self; 10080 } 10081 10082 - (instancetype)initWithCapacity:(NSUInteger)numItems { 10083 #pragma unused(numItems) 10084 return [self initWithValues:NULL forKeys:NULL count:0]; 10085 } 10086 10087 - (void)dealloc { 10088 NSAssert(!_autocreator, 10089 @"%@: Autocreator must be cleared before release, autocreator: %@", 10090 [self class], _autocreator); 10091 [_dictionary release]; 10092 [super dealloc]; 10093 } 10094 10095 - (instancetype)copyWithZone:(NSZone *)zone { 10096 return [[GPBStringInt64Dictionary allocWithZone:zone] initWithDictionary:self]; 10097 } 10098 10099 - (BOOL)isEqual:(GPBStringInt64Dictionary *)other { 10100 if (self == other) { 10101 return YES; 10102 } 10103 if (![other isKindOfClass:[GPBStringInt64Dictionary class]]) { 10104 return NO; 10105 } 10106 return [_dictionary isEqual:other->_dictionary]; 10107 } 10108 10109 - (NSUInteger)hash { 10110 return _dictionary.count; 10111 } 10112 10113 - (NSString *)description { 10114 return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 10115 } 10116 10117 - (NSUInteger)count { 10118 return _dictionary.count; 10119 } 10120 10121 - (void)enumerateKeysAndValuesUsingBlock: 10122 (void (^)(NSString *key, int64_t value, BOOL *stop))block { 10123 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSString *aKey, 10124 NSNumber *aValue, 10125 BOOL *stop) { 10126 block(aKey, [aValue longLongValue], stop); 10127 }]; 10128 } 10129 10130 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 10131 NSUInteger count = _dictionary.count; 10132 if (count == 0) { 10133 return 0; 10134 } 10135 10136 GPBDataType valueDataType = GPBGetFieldDataType(field); 10137 GPBDataType keyDataType = field.mapKeyDataType; 10138 __block size_t result = 0; 10139 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSString *aKey, 10140 NSNumber *aValue, 10141 BOOL *stop) { 10142 #pragma unused(stop) 10143 size_t msgSize = ComputeDictStringFieldSize(aKey, kMapKeyFieldNumber, keyDataType); 10144 msgSize += ComputeDictInt64FieldSize([aValue longLongValue], kMapValueFieldNumber, valueDataType); 10145 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 10146 }]; 10147 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 10148 result += tagSize * count; 10149 return result; 10150 } 10151 10152 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 10153 asField:(GPBFieldDescriptor *)field { 10154 GPBDataType valueDataType = GPBGetFieldDataType(field); 10155 GPBDataType keyDataType = field.mapKeyDataType; 10156 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 10157 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSString *aKey, 10158 NSNumber *aValue, 10159 BOOL *stop) { 10160 #pragma unused(stop) 10161 // Write the tag. 10162 [outputStream writeInt32NoTag:tag]; 10163 // Write the size of the message. 10164 size_t msgSize = ComputeDictStringFieldSize(aKey, kMapKeyFieldNumber, keyDataType); 10165 msgSize += ComputeDictInt64FieldSize([aValue longLongValue], kMapValueFieldNumber, valueDataType); 10166 [outputStream writeInt32NoTag:(int32_t)msgSize]; 10167 // Write the fields. 10168 WriteDictStringField(outputStream, aKey, kMapKeyFieldNumber, keyDataType); 10169 WriteDictInt64Field(outputStream, [aValue longLongValue], kMapValueFieldNumber, valueDataType); 10170 }]; 10171 } 10172 10173 - (void)setGPBGenericValue:(GPBGenericValue *)value 10174 forGPBGenericValueKey:(GPBGenericValue *)key { 10175 [_dictionary setObject:@(value->valueInt64) forKey:key->valueString]; 10176 } 10177 10178 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 10179 [self enumerateKeysAndValuesUsingBlock:^(NSString *key, int64_t value, BOOL *stop) { 10180 #pragma unused(stop) 10181 block(key, [NSString stringWithFormat:@"%lld", value]); 10182 }]; 10183 } 10184 10185 - (BOOL)valueForKey:(NSString *)key value:(int64_t *)value { 10186 NSNumber *wrapped = [_dictionary objectForKey:key]; 10187 if (wrapped && value) { 10188 *value = [wrapped longLongValue]; 10189 } 10190 return (wrapped != NULL); 10191 } 10192 10193 - (void)addEntriesFromDictionary:(GPBStringInt64Dictionary *)otherDictionary { 10194 if (otherDictionary) { 10195 [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 10196 if (_autocreator) { 10197 GPBAutocreatedDictionaryModified(_autocreator, self); 10198 } 10199 } 10200 } 10201 10202 - (void)setValue:(int64_t)value forKey:(NSString *)key { 10203 if (!key) { 10204 [NSException raise:NSInvalidArgumentException 10205 format:@"Attempting to add nil key to a Dictionary"]; 10206 } 10207 [_dictionary setObject:@(value) forKey:key]; 10208 if (_autocreator) { 10209 GPBAutocreatedDictionaryModified(_autocreator, self); 10210 } 10211 } 10212 10213 - (void)removeValueForKey:(NSString *)aKey { 10214 [_dictionary removeObjectForKey:aKey]; 10215 } 10216 10217 - (void)removeAll { 10218 [_dictionary removeAllObjects]; 10219 } 10220 10221 @end 10222 10223 #pragma mark - String -> Bool 10224 10225 @implementation GPBStringBoolDictionary { 10226 @package 10227 NSMutableDictionary *_dictionary; 10228 } 10229 10230 + (instancetype)dictionary { 10231 return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; 10232 } 10233 10234 + (instancetype)dictionaryWithValue:(BOOL)value 10235 forKey:(NSString *)key { 10236 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 10237 // on to get the type correct. 10238 return [[(GPBStringBoolDictionary*)[self alloc] initWithValues:&value 10239 forKeys:&key 10240 count:1] autorelease]; 10241 } 10242 10243 + (instancetype)dictionaryWithValues:(const BOOL [])values 10244 forKeys:(const NSString * [])keys 10245 count:(NSUInteger)count { 10246 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 10247 // on to get the type correct. 10248 return [[(GPBStringBoolDictionary*)[self alloc] initWithValues:values 10249 forKeys:keys 10250 count:count] autorelease]; 10251 } 10252 10253 + (instancetype)dictionaryWithDictionary:(GPBStringBoolDictionary *)dictionary { 10254 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 10255 // on to get the type correct. 10256 return [[(GPBStringBoolDictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 10257 } 10258 10259 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 10260 return [[[self alloc] initWithCapacity:numItems] autorelease]; 10261 } 10262 10263 - (instancetype)init { 10264 return [self initWithValues:NULL forKeys:NULL count:0]; 10265 } 10266 10267 - (instancetype)initWithValues:(const BOOL [])values 10268 forKeys:(const NSString * [])keys 10269 count:(NSUInteger)count { 10270 self = [super init]; 10271 if (self) { 10272 _dictionary = [[NSMutableDictionary alloc] init]; 10273 if (count && values && keys) { 10274 for (NSUInteger i = 0; i < count; ++i) { 10275 if (!keys[i]) { 10276 [NSException raise:NSInvalidArgumentException 10277 format:@"Attempting to add nil key to a Dictionary"]; 10278 } 10279 [_dictionary setObject:@(values[i]) forKey:keys[i]]; 10280 } 10281 } 10282 } 10283 return self; 10284 } 10285 10286 - (instancetype)initWithDictionary:(GPBStringBoolDictionary *)dictionary { 10287 self = [self initWithValues:NULL forKeys:NULL count:0]; 10288 if (self) { 10289 if (dictionary) { 10290 [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 10291 } 10292 } 10293 return self; 10294 } 10295 10296 - (instancetype)initWithCapacity:(NSUInteger)numItems { 10297 #pragma unused(numItems) 10298 return [self initWithValues:NULL forKeys:NULL count:0]; 10299 } 10300 10301 - (void)dealloc { 10302 NSAssert(!_autocreator, 10303 @"%@: Autocreator must be cleared before release, autocreator: %@", 10304 [self class], _autocreator); 10305 [_dictionary release]; 10306 [super dealloc]; 10307 } 10308 10309 - (instancetype)copyWithZone:(NSZone *)zone { 10310 return [[GPBStringBoolDictionary allocWithZone:zone] initWithDictionary:self]; 10311 } 10312 10313 - (BOOL)isEqual:(GPBStringBoolDictionary *)other { 10314 if (self == other) { 10315 return YES; 10316 } 10317 if (![other isKindOfClass:[GPBStringBoolDictionary class]]) { 10318 return NO; 10319 } 10320 return [_dictionary isEqual:other->_dictionary]; 10321 } 10322 10323 - (NSUInteger)hash { 10324 return _dictionary.count; 10325 } 10326 10327 - (NSString *)description { 10328 return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 10329 } 10330 10331 - (NSUInteger)count { 10332 return _dictionary.count; 10333 } 10334 10335 - (void)enumerateKeysAndValuesUsingBlock: 10336 (void (^)(NSString *key, BOOL value, BOOL *stop))block { 10337 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSString *aKey, 10338 NSNumber *aValue, 10339 BOOL *stop) { 10340 block(aKey, [aValue boolValue], stop); 10341 }]; 10342 } 10343 10344 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 10345 NSUInteger count = _dictionary.count; 10346 if (count == 0) { 10347 return 0; 10348 } 10349 10350 GPBDataType valueDataType = GPBGetFieldDataType(field); 10351 GPBDataType keyDataType = field.mapKeyDataType; 10352 __block size_t result = 0; 10353 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSString *aKey, 10354 NSNumber *aValue, 10355 BOOL *stop) { 10356 #pragma unused(stop) 10357 size_t msgSize = ComputeDictStringFieldSize(aKey, kMapKeyFieldNumber, keyDataType); 10358 msgSize += ComputeDictBoolFieldSize([aValue boolValue], kMapValueFieldNumber, valueDataType); 10359 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 10360 }]; 10361 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 10362 result += tagSize * count; 10363 return result; 10364 } 10365 10366 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 10367 asField:(GPBFieldDescriptor *)field { 10368 GPBDataType valueDataType = GPBGetFieldDataType(field); 10369 GPBDataType keyDataType = field.mapKeyDataType; 10370 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 10371 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSString *aKey, 10372 NSNumber *aValue, 10373 BOOL *stop) { 10374 #pragma unused(stop) 10375 // Write the tag. 10376 [outputStream writeInt32NoTag:tag]; 10377 // Write the size of the message. 10378 size_t msgSize = ComputeDictStringFieldSize(aKey, kMapKeyFieldNumber, keyDataType); 10379 msgSize += ComputeDictBoolFieldSize([aValue boolValue], kMapValueFieldNumber, valueDataType); 10380 [outputStream writeInt32NoTag:(int32_t)msgSize]; 10381 // Write the fields. 10382 WriteDictStringField(outputStream, aKey, kMapKeyFieldNumber, keyDataType); 10383 WriteDictBoolField(outputStream, [aValue boolValue], kMapValueFieldNumber, valueDataType); 10384 }]; 10385 } 10386 10387 - (void)setGPBGenericValue:(GPBGenericValue *)value 10388 forGPBGenericValueKey:(GPBGenericValue *)key { 10389 [_dictionary setObject:@(value->valueBool) forKey:key->valueString]; 10390 } 10391 10392 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 10393 [self enumerateKeysAndValuesUsingBlock:^(NSString *key, BOOL value, BOOL *stop) { 10394 #pragma unused(stop) 10395 block(key, (value ? @"true" : @"false")); 10396 }]; 10397 } 10398 10399 - (BOOL)valueForKey:(NSString *)key value:(BOOL *)value { 10400 NSNumber *wrapped = [_dictionary objectForKey:key]; 10401 if (wrapped && value) { 10402 *value = [wrapped boolValue]; 10403 } 10404 return (wrapped != NULL); 10405 } 10406 10407 - (void)addEntriesFromDictionary:(GPBStringBoolDictionary *)otherDictionary { 10408 if (otherDictionary) { 10409 [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 10410 if (_autocreator) { 10411 GPBAutocreatedDictionaryModified(_autocreator, self); 10412 } 10413 } 10414 } 10415 10416 - (void)setValue:(BOOL)value forKey:(NSString *)key { 10417 if (!key) { 10418 [NSException raise:NSInvalidArgumentException 10419 format:@"Attempting to add nil key to a Dictionary"]; 10420 } 10421 [_dictionary setObject:@(value) forKey:key]; 10422 if (_autocreator) { 10423 GPBAutocreatedDictionaryModified(_autocreator, self); 10424 } 10425 } 10426 10427 - (void)removeValueForKey:(NSString *)aKey { 10428 [_dictionary removeObjectForKey:aKey]; 10429 } 10430 10431 - (void)removeAll { 10432 [_dictionary removeAllObjects]; 10433 } 10434 10435 @end 10436 10437 #pragma mark - String -> Float 10438 10439 @implementation GPBStringFloatDictionary { 10440 @package 10441 NSMutableDictionary *_dictionary; 10442 } 10443 10444 + (instancetype)dictionary { 10445 return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; 10446 } 10447 10448 + (instancetype)dictionaryWithValue:(float)value 10449 forKey:(NSString *)key { 10450 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 10451 // on to get the type correct. 10452 return [[(GPBStringFloatDictionary*)[self alloc] initWithValues:&value 10453 forKeys:&key 10454 count:1] autorelease]; 10455 } 10456 10457 + (instancetype)dictionaryWithValues:(const float [])values 10458 forKeys:(const NSString * [])keys 10459 count:(NSUInteger)count { 10460 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 10461 // on to get the type correct. 10462 return [[(GPBStringFloatDictionary*)[self alloc] initWithValues:values 10463 forKeys:keys 10464 count:count] autorelease]; 10465 } 10466 10467 + (instancetype)dictionaryWithDictionary:(GPBStringFloatDictionary *)dictionary { 10468 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 10469 // on to get the type correct. 10470 return [[(GPBStringFloatDictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 10471 } 10472 10473 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 10474 return [[[self alloc] initWithCapacity:numItems] autorelease]; 10475 } 10476 10477 - (instancetype)init { 10478 return [self initWithValues:NULL forKeys:NULL count:0]; 10479 } 10480 10481 - (instancetype)initWithValues:(const float [])values 10482 forKeys:(const NSString * [])keys 10483 count:(NSUInteger)count { 10484 self = [super init]; 10485 if (self) { 10486 _dictionary = [[NSMutableDictionary alloc] init]; 10487 if (count && values && keys) { 10488 for (NSUInteger i = 0; i < count; ++i) { 10489 if (!keys[i]) { 10490 [NSException raise:NSInvalidArgumentException 10491 format:@"Attempting to add nil key to a Dictionary"]; 10492 } 10493 [_dictionary setObject:@(values[i]) forKey:keys[i]]; 10494 } 10495 } 10496 } 10497 return self; 10498 } 10499 10500 - (instancetype)initWithDictionary:(GPBStringFloatDictionary *)dictionary { 10501 self = [self initWithValues:NULL forKeys:NULL count:0]; 10502 if (self) { 10503 if (dictionary) { 10504 [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 10505 } 10506 } 10507 return self; 10508 } 10509 10510 - (instancetype)initWithCapacity:(NSUInteger)numItems { 10511 #pragma unused(numItems) 10512 return [self initWithValues:NULL forKeys:NULL count:0]; 10513 } 10514 10515 - (void)dealloc { 10516 NSAssert(!_autocreator, 10517 @"%@: Autocreator must be cleared before release, autocreator: %@", 10518 [self class], _autocreator); 10519 [_dictionary release]; 10520 [super dealloc]; 10521 } 10522 10523 - (instancetype)copyWithZone:(NSZone *)zone { 10524 return [[GPBStringFloatDictionary allocWithZone:zone] initWithDictionary:self]; 10525 } 10526 10527 - (BOOL)isEqual:(GPBStringFloatDictionary *)other { 10528 if (self == other) { 10529 return YES; 10530 } 10531 if (![other isKindOfClass:[GPBStringFloatDictionary class]]) { 10532 return NO; 10533 } 10534 return [_dictionary isEqual:other->_dictionary]; 10535 } 10536 10537 - (NSUInteger)hash { 10538 return _dictionary.count; 10539 } 10540 10541 - (NSString *)description { 10542 return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 10543 } 10544 10545 - (NSUInteger)count { 10546 return _dictionary.count; 10547 } 10548 10549 - (void)enumerateKeysAndValuesUsingBlock: 10550 (void (^)(NSString *key, float value, BOOL *stop))block { 10551 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSString *aKey, 10552 NSNumber *aValue, 10553 BOOL *stop) { 10554 block(aKey, [aValue floatValue], stop); 10555 }]; 10556 } 10557 10558 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 10559 NSUInteger count = _dictionary.count; 10560 if (count == 0) { 10561 return 0; 10562 } 10563 10564 GPBDataType valueDataType = GPBGetFieldDataType(field); 10565 GPBDataType keyDataType = field.mapKeyDataType; 10566 __block size_t result = 0; 10567 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSString *aKey, 10568 NSNumber *aValue, 10569 BOOL *stop) { 10570 #pragma unused(stop) 10571 size_t msgSize = ComputeDictStringFieldSize(aKey, kMapKeyFieldNumber, keyDataType); 10572 msgSize += ComputeDictFloatFieldSize([aValue floatValue], kMapValueFieldNumber, valueDataType); 10573 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 10574 }]; 10575 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 10576 result += tagSize * count; 10577 return result; 10578 } 10579 10580 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 10581 asField:(GPBFieldDescriptor *)field { 10582 GPBDataType valueDataType = GPBGetFieldDataType(field); 10583 GPBDataType keyDataType = field.mapKeyDataType; 10584 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 10585 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSString *aKey, 10586 NSNumber *aValue, 10587 BOOL *stop) { 10588 #pragma unused(stop) 10589 // Write the tag. 10590 [outputStream writeInt32NoTag:tag]; 10591 // Write the size of the message. 10592 size_t msgSize = ComputeDictStringFieldSize(aKey, kMapKeyFieldNumber, keyDataType); 10593 msgSize += ComputeDictFloatFieldSize([aValue floatValue], kMapValueFieldNumber, valueDataType); 10594 [outputStream writeInt32NoTag:(int32_t)msgSize]; 10595 // Write the fields. 10596 WriteDictStringField(outputStream, aKey, kMapKeyFieldNumber, keyDataType); 10597 WriteDictFloatField(outputStream, [aValue floatValue], kMapValueFieldNumber, valueDataType); 10598 }]; 10599 } 10600 10601 - (void)setGPBGenericValue:(GPBGenericValue *)value 10602 forGPBGenericValueKey:(GPBGenericValue *)key { 10603 [_dictionary setObject:@(value->valueFloat) forKey:key->valueString]; 10604 } 10605 10606 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 10607 [self enumerateKeysAndValuesUsingBlock:^(NSString *key, float value, BOOL *stop) { 10608 #pragma unused(stop) 10609 block(key, [NSString stringWithFormat:@"%.*g", FLT_DIG, value]); 10610 }]; 10611 } 10612 10613 - (BOOL)valueForKey:(NSString *)key value:(float *)value { 10614 NSNumber *wrapped = [_dictionary objectForKey:key]; 10615 if (wrapped && value) { 10616 *value = [wrapped floatValue]; 10617 } 10618 return (wrapped != NULL); 10619 } 10620 10621 - (void)addEntriesFromDictionary:(GPBStringFloatDictionary *)otherDictionary { 10622 if (otherDictionary) { 10623 [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 10624 if (_autocreator) { 10625 GPBAutocreatedDictionaryModified(_autocreator, self); 10626 } 10627 } 10628 } 10629 10630 - (void)setValue:(float)value forKey:(NSString *)key { 10631 if (!key) { 10632 [NSException raise:NSInvalidArgumentException 10633 format:@"Attempting to add nil key to a Dictionary"]; 10634 } 10635 [_dictionary setObject:@(value) forKey:key]; 10636 if (_autocreator) { 10637 GPBAutocreatedDictionaryModified(_autocreator, self); 10638 } 10639 } 10640 10641 - (void)removeValueForKey:(NSString *)aKey { 10642 [_dictionary removeObjectForKey:aKey]; 10643 } 10644 10645 - (void)removeAll { 10646 [_dictionary removeAllObjects]; 10647 } 10648 10649 @end 10650 10651 #pragma mark - String -> Double 10652 10653 @implementation GPBStringDoubleDictionary { 10654 @package 10655 NSMutableDictionary *_dictionary; 10656 } 10657 10658 + (instancetype)dictionary { 10659 return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; 10660 } 10661 10662 + (instancetype)dictionaryWithValue:(double)value 10663 forKey:(NSString *)key { 10664 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 10665 // on to get the type correct. 10666 return [[(GPBStringDoubleDictionary*)[self alloc] initWithValues:&value 10667 forKeys:&key 10668 count:1] autorelease]; 10669 } 10670 10671 + (instancetype)dictionaryWithValues:(const double [])values 10672 forKeys:(const NSString * [])keys 10673 count:(NSUInteger)count { 10674 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 10675 // on to get the type correct. 10676 return [[(GPBStringDoubleDictionary*)[self alloc] initWithValues:values 10677 forKeys:keys 10678 count:count] autorelease]; 10679 } 10680 10681 + (instancetype)dictionaryWithDictionary:(GPBStringDoubleDictionary *)dictionary { 10682 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 10683 // on to get the type correct. 10684 return [[(GPBStringDoubleDictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 10685 } 10686 10687 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 10688 return [[[self alloc] initWithCapacity:numItems] autorelease]; 10689 } 10690 10691 - (instancetype)init { 10692 return [self initWithValues:NULL forKeys:NULL count:0]; 10693 } 10694 10695 - (instancetype)initWithValues:(const double [])values 10696 forKeys:(const NSString * [])keys 10697 count:(NSUInteger)count { 10698 self = [super init]; 10699 if (self) { 10700 _dictionary = [[NSMutableDictionary alloc] init]; 10701 if (count && values && keys) { 10702 for (NSUInteger i = 0; i < count; ++i) { 10703 if (!keys[i]) { 10704 [NSException raise:NSInvalidArgumentException 10705 format:@"Attempting to add nil key to a Dictionary"]; 10706 } 10707 [_dictionary setObject:@(values[i]) forKey:keys[i]]; 10708 } 10709 } 10710 } 10711 return self; 10712 } 10713 10714 - (instancetype)initWithDictionary:(GPBStringDoubleDictionary *)dictionary { 10715 self = [self initWithValues:NULL forKeys:NULL count:0]; 10716 if (self) { 10717 if (dictionary) { 10718 [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 10719 } 10720 } 10721 return self; 10722 } 10723 10724 - (instancetype)initWithCapacity:(NSUInteger)numItems { 10725 #pragma unused(numItems) 10726 return [self initWithValues:NULL forKeys:NULL count:0]; 10727 } 10728 10729 - (void)dealloc { 10730 NSAssert(!_autocreator, 10731 @"%@: Autocreator must be cleared before release, autocreator: %@", 10732 [self class], _autocreator); 10733 [_dictionary release]; 10734 [super dealloc]; 10735 } 10736 10737 - (instancetype)copyWithZone:(NSZone *)zone { 10738 return [[GPBStringDoubleDictionary allocWithZone:zone] initWithDictionary:self]; 10739 } 10740 10741 - (BOOL)isEqual:(GPBStringDoubleDictionary *)other { 10742 if (self == other) { 10743 return YES; 10744 } 10745 if (![other isKindOfClass:[GPBStringDoubleDictionary class]]) { 10746 return NO; 10747 } 10748 return [_dictionary isEqual:other->_dictionary]; 10749 } 10750 10751 - (NSUInteger)hash { 10752 return _dictionary.count; 10753 } 10754 10755 - (NSString *)description { 10756 return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 10757 } 10758 10759 - (NSUInteger)count { 10760 return _dictionary.count; 10761 } 10762 10763 - (void)enumerateKeysAndValuesUsingBlock: 10764 (void (^)(NSString *key, double value, BOOL *stop))block { 10765 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSString *aKey, 10766 NSNumber *aValue, 10767 BOOL *stop) { 10768 block(aKey, [aValue doubleValue], stop); 10769 }]; 10770 } 10771 10772 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 10773 NSUInteger count = _dictionary.count; 10774 if (count == 0) { 10775 return 0; 10776 } 10777 10778 GPBDataType valueDataType = GPBGetFieldDataType(field); 10779 GPBDataType keyDataType = field.mapKeyDataType; 10780 __block size_t result = 0; 10781 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSString *aKey, 10782 NSNumber *aValue, 10783 BOOL *stop) { 10784 #pragma unused(stop) 10785 size_t msgSize = ComputeDictStringFieldSize(aKey, kMapKeyFieldNumber, keyDataType); 10786 msgSize += ComputeDictDoubleFieldSize([aValue doubleValue], kMapValueFieldNumber, valueDataType); 10787 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 10788 }]; 10789 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 10790 result += tagSize * count; 10791 return result; 10792 } 10793 10794 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 10795 asField:(GPBFieldDescriptor *)field { 10796 GPBDataType valueDataType = GPBGetFieldDataType(field); 10797 GPBDataType keyDataType = field.mapKeyDataType; 10798 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 10799 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSString *aKey, 10800 NSNumber *aValue, 10801 BOOL *stop) { 10802 #pragma unused(stop) 10803 // Write the tag. 10804 [outputStream writeInt32NoTag:tag]; 10805 // Write the size of the message. 10806 size_t msgSize = ComputeDictStringFieldSize(aKey, kMapKeyFieldNumber, keyDataType); 10807 msgSize += ComputeDictDoubleFieldSize([aValue doubleValue], kMapValueFieldNumber, valueDataType); 10808 [outputStream writeInt32NoTag:(int32_t)msgSize]; 10809 // Write the fields. 10810 WriteDictStringField(outputStream, aKey, kMapKeyFieldNumber, keyDataType); 10811 WriteDictDoubleField(outputStream, [aValue doubleValue], kMapValueFieldNumber, valueDataType); 10812 }]; 10813 } 10814 10815 - (void)setGPBGenericValue:(GPBGenericValue *)value 10816 forGPBGenericValueKey:(GPBGenericValue *)key { 10817 [_dictionary setObject:@(value->valueDouble) forKey:key->valueString]; 10818 } 10819 10820 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 10821 [self enumerateKeysAndValuesUsingBlock:^(NSString *key, double value, BOOL *stop) { 10822 #pragma unused(stop) 10823 block(key, [NSString stringWithFormat:@"%.*lg", DBL_DIG, value]); 10824 }]; 10825 } 10826 10827 - (BOOL)valueForKey:(NSString *)key value:(double *)value { 10828 NSNumber *wrapped = [_dictionary objectForKey:key]; 10829 if (wrapped && value) { 10830 *value = [wrapped doubleValue]; 10831 } 10832 return (wrapped != NULL); 10833 } 10834 10835 - (void)addEntriesFromDictionary:(GPBStringDoubleDictionary *)otherDictionary { 10836 if (otherDictionary) { 10837 [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 10838 if (_autocreator) { 10839 GPBAutocreatedDictionaryModified(_autocreator, self); 10840 } 10841 } 10842 } 10843 10844 - (void)setValue:(double)value forKey:(NSString *)key { 10845 if (!key) { 10846 [NSException raise:NSInvalidArgumentException 10847 format:@"Attempting to add nil key to a Dictionary"]; 10848 } 10849 [_dictionary setObject:@(value) forKey:key]; 10850 if (_autocreator) { 10851 GPBAutocreatedDictionaryModified(_autocreator, self); 10852 } 10853 } 10854 10855 - (void)removeValueForKey:(NSString *)aKey { 10856 [_dictionary removeObjectForKey:aKey]; 10857 } 10858 10859 - (void)removeAll { 10860 [_dictionary removeAllObjects]; 10861 } 10862 10863 @end 10864 10865 #pragma mark - String -> Enum 10866 10867 @implementation GPBStringEnumDictionary { 10868 @package 10869 NSMutableDictionary *_dictionary; 10870 GPBEnumValidationFunc _validationFunc; 10871 } 10872 10873 @synthesize validationFunc = _validationFunc; 10874 10875 + (instancetype)dictionary { 10876 return [[[self alloc] initWithValidationFunction:NULL 10877 rawValues:NULL 10878 forKeys:NULL 10879 count:0] autorelease]; 10880 } 10881 10882 + (instancetype)dictionaryWithValidationFunction:(GPBEnumValidationFunc)func { 10883 return [[[self alloc] initWithValidationFunction:func 10884 rawValues:NULL 10885 forKeys:NULL 10886 count:0] autorelease]; 10887 } 10888 10889 + (instancetype)dictionaryWithValidationFunction:(GPBEnumValidationFunc)func 10890 rawValue:(int32_t)rawValue 10891 forKey:(NSString *)key { 10892 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 10893 // on to get the type correct. 10894 return [[(GPBStringEnumDictionary*)[self alloc] initWithValidationFunction:func 10895 rawValues:&rawValue 10896 forKeys:&key 10897 count:1] autorelease]; 10898 } 10899 10900 + (instancetype)dictionaryWithValidationFunction:(GPBEnumValidationFunc)func 10901 rawValues:(const int32_t [])rawValues 10902 forKeys:(const NSString * [])keys 10903 count:(NSUInteger)count { 10904 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 10905 // on to get the type correct. 10906 return [[(GPBStringEnumDictionary*)[self alloc] initWithValidationFunction:func 10907 rawValues:rawValues 10908 forKeys:keys 10909 count:count] autorelease]; 10910 } 10911 10912 + (instancetype)dictionaryWithDictionary:(GPBStringEnumDictionary *)dictionary { 10913 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 10914 // on to get the type correct. 10915 return [[(GPBStringEnumDictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 10916 } 10917 10918 + (instancetype)dictionaryWithValidationFunction:(GPBEnumValidationFunc)func 10919 capacity:(NSUInteger)numItems { 10920 return [[[self alloc] initWithValidationFunction:func capacity:numItems] autorelease]; 10921 } 10922 10923 - (instancetype)init { 10924 return [self initWithValidationFunction:NULL rawValues:NULL forKeys:NULL count:0]; 10925 } 10926 10927 - (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func { 10928 return [self initWithValidationFunction:func rawValues:NULL forKeys:NULL count:0]; 10929 } 10930 10931 - (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func 10932 rawValues:(const int32_t [])rawValues 10933 forKeys:(const NSString * [])keys 10934 count:(NSUInteger)count { 10935 self = [super init]; 10936 if (self) { 10937 _dictionary = [[NSMutableDictionary alloc] init]; 10938 _validationFunc = (func != NULL ? func : DictDefault_IsValidValue); 10939 if (count && rawValues && keys) { 10940 for (NSUInteger i = 0; i < count; ++i) { 10941 if (!keys[i]) { 10942 [NSException raise:NSInvalidArgumentException 10943 format:@"Attempting to add nil key to a Dictionary"]; 10944 } 10945 [_dictionary setObject:@(rawValues[i]) forKey:keys[i]]; 10946 } 10947 } 10948 } 10949 return self; 10950 } 10951 10952 - (instancetype)initWithDictionary:(GPBStringEnumDictionary *)dictionary { 10953 self = [self initWithValidationFunction:dictionary.validationFunc 10954 rawValues:NULL 10955 forKeys:NULL 10956 count:0]; 10957 if (self) { 10958 if (dictionary) { 10959 [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; 10960 } 10961 } 10962 return self; 10963 } 10964 10965 - (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func 10966 capacity:(NSUInteger)numItems { 10967 #pragma unused(numItems) 10968 return [self initWithValidationFunction:func rawValues:NULL forKeys:NULL count:0]; 10969 } 10970 10971 - (void)dealloc { 10972 NSAssert(!_autocreator, 10973 @"%@: Autocreator must be cleared before release, autocreator: %@", 10974 [self class], _autocreator); 10975 [_dictionary release]; 10976 [super dealloc]; 10977 } 10978 10979 - (instancetype)copyWithZone:(NSZone *)zone { 10980 return [[GPBStringEnumDictionary allocWithZone:zone] initWithDictionary:self]; 10981 } 10982 10983 - (BOOL)isEqual:(GPBStringEnumDictionary *)other { 10984 if (self == other) { 10985 return YES; 10986 } 10987 if (![other isKindOfClass:[GPBStringEnumDictionary class]]) { 10988 return NO; 10989 } 10990 return [_dictionary isEqual:other->_dictionary]; 10991 } 10992 10993 - (NSUInteger)hash { 10994 return _dictionary.count; 10995 } 10996 10997 - (NSString *)description { 10998 return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary]; 10999 } 11000 11001 - (NSUInteger)count { 11002 return _dictionary.count; 11003 } 11004 11005 - (void)enumerateKeysAndRawValuesUsingBlock: 11006 (void (^)(NSString *key, int32_t value, BOOL *stop))block { 11007 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSString *aKey, 11008 NSNumber *aValue, 11009 BOOL *stop) { 11010 block(aKey, [aValue intValue], stop); 11011 }]; 11012 } 11013 11014 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 11015 NSUInteger count = _dictionary.count; 11016 if (count == 0) { 11017 return 0; 11018 } 11019 11020 GPBDataType valueDataType = GPBGetFieldDataType(field); 11021 GPBDataType keyDataType = field.mapKeyDataType; 11022 __block size_t result = 0; 11023 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSString *aKey, 11024 NSNumber *aValue, 11025 BOOL *stop) { 11026 #pragma unused(stop) 11027 size_t msgSize = ComputeDictStringFieldSize(aKey, kMapKeyFieldNumber, keyDataType); 11028 msgSize += ComputeDictEnumFieldSize([aValue intValue], kMapValueFieldNumber, valueDataType); 11029 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 11030 }]; 11031 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 11032 result += tagSize * count; 11033 return result; 11034 } 11035 11036 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 11037 asField:(GPBFieldDescriptor *)field { 11038 GPBDataType valueDataType = GPBGetFieldDataType(field); 11039 GPBDataType keyDataType = field.mapKeyDataType; 11040 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 11041 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSString *aKey, 11042 NSNumber *aValue, 11043 BOOL *stop) { 11044 #pragma unused(stop) 11045 // Write the tag. 11046 [outputStream writeInt32NoTag:tag]; 11047 // Write the size of the message. 11048 size_t msgSize = ComputeDictStringFieldSize(aKey, kMapKeyFieldNumber, keyDataType); 11049 msgSize += ComputeDictEnumFieldSize([aValue intValue], kMapValueFieldNumber, valueDataType); 11050 [outputStream writeInt32NoTag:(int32_t)msgSize]; 11051 // Write the fields. 11052 WriteDictStringField(outputStream, aKey, kMapKeyFieldNumber, keyDataType); 11053 WriteDictEnumField(outputStream, [aValue intValue], kMapValueFieldNumber, valueDataType); 11054 }]; 11055 } 11056 11057 - (NSData *)serializedDataForUnknownValue:(int32_t)value 11058 forKey:(GPBGenericValue *)key 11059 keyDataType:(GPBDataType)keyDataType { 11060 size_t msgSize = ComputeDictStringFieldSize(key->valueString, kMapKeyFieldNumber, keyDataType); 11061 msgSize += ComputeDictEnumFieldSize(value, kMapValueFieldNumber, GPBDataTypeEnum); 11062 NSMutableData *data = [NSMutableData dataWithLength:msgSize]; 11063 GPBCodedOutputStream *outputStream = [[GPBCodedOutputStream alloc] initWithData:data]; 11064 WriteDictStringField(outputStream, key->valueString, kMapKeyFieldNumber, keyDataType); 11065 WriteDictEnumField(outputStream, value, kMapValueFieldNumber, GPBDataTypeEnum); 11066 [outputStream release]; 11067 return data; 11068 } 11069 - (void)setGPBGenericValue:(GPBGenericValue *)value 11070 forGPBGenericValueKey:(GPBGenericValue *)key { 11071 [_dictionary setObject:@(value->valueEnum) forKey:key->valueString]; 11072 } 11073 11074 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 11075 [self enumerateKeysAndRawValuesUsingBlock:^(NSString *key, int32_t value, BOOL *stop) { 11076 #pragma unused(stop) 11077 block(key, @(value)); 11078 }]; 11079 } 11080 11081 - (BOOL)valueForKey:(NSString *)key value:(int32_t *)value { 11082 NSNumber *wrapped = [_dictionary objectForKey:key]; 11083 if (wrapped && value) { 11084 int32_t result = [wrapped intValue]; 11085 if (!_validationFunc(result)) { 11086 result = kGPBUnrecognizedEnumeratorValue; 11087 } 11088 *value = result; 11089 } 11090 return (wrapped != NULL); 11091 } 11092 11093 - (BOOL)valueForKey:(NSString *)key rawValue:(int32_t *)rawValue { 11094 NSNumber *wrapped = [_dictionary objectForKey:key]; 11095 if (wrapped && rawValue) { 11096 *rawValue = [wrapped intValue]; 11097 } 11098 return (wrapped != NULL); 11099 } 11100 11101 - (void)enumerateKeysAndValuesUsingBlock: 11102 (void (^)(NSString *key, int32_t value, BOOL *stop))block { 11103 GPBEnumValidationFunc func = _validationFunc; 11104 [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSString *aKey, 11105 NSNumber *aValue, 11106 BOOL *stop) { 11107 int32_t unwrapped = [aValue intValue]; 11108 if (!func(unwrapped)) { 11109 unwrapped = kGPBUnrecognizedEnumeratorValue; 11110 } 11111 block(aKey, unwrapped, stop); 11112 }]; 11113 } 11114 11115 - (void)addRawEntriesFromDictionary:(GPBStringEnumDictionary *)otherDictionary { 11116 if (otherDictionary) { 11117 [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; 11118 if (_autocreator) { 11119 GPBAutocreatedDictionaryModified(_autocreator, self); 11120 } 11121 } 11122 } 11123 11124 - (void)setRawValue:(int32_t)value forKey:(NSString *)key { 11125 if (!key) { 11126 [NSException raise:NSInvalidArgumentException 11127 format:@"Attempting to add nil key to a Dictionary"]; 11128 } 11129 [_dictionary setObject:@(value) forKey:key]; 11130 if (_autocreator) { 11131 GPBAutocreatedDictionaryModified(_autocreator, self); 11132 } 11133 } 11134 11135 - (void)removeValueForKey:(NSString *)aKey { 11136 [_dictionary removeObjectForKey:aKey]; 11137 } 11138 11139 - (void)removeAll { 11140 [_dictionary removeAllObjects]; 11141 } 11142 11143 - (void)setValue:(int32_t)value forKey:(NSString *)key { 11144 if (!key) { 11145 [NSException raise:NSInvalidArgumentException 11146 format:@"Attempting to add nil key to a Dictionary"]; 11147 } 11148 if (!_validationFunc(value)) { 11149 [NSException raise:NSInvalidArgumentException 11150 format:@"GPBStringEnumDictionary: Attempt to set an unknown enum value (%d)", 11151 value]; 11152 } 11153 11154 [_dictionary setObject:@(value) forKey:key]; 11155 if (_autocreator) { 11156 GPBAutocreatedDictionaryModified(_autocreator, self); 11157 } 11158 } 11159 11160 @end 11161 11162 //%PDDM-EXPAND-END (5 expansions) 11163 11164 11165 //%PDDM-EXPAND DICTIONARY_BOOL_KEY_TO_POD_IMPL(UInt32, uint32_t) 11166 // This block of code is generated, do not edit it directly. 11167 11168 #pragma mark - Bool -> UInt32 11169 11170 @implementation GPBBoolUInt32Dictionary { 11171 @package 11172 uint32_t _values[2]; 11173 BOOL _valueSet[2]; 11174 } 11175 11176 + (instancetype)dictionary { 11177 return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; 11178 } 11179 11180 + (instancetype)dictionaryWithValue:(uint32_t)value 11181 forKey:(BOOL)key { 11182 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 11183 // on to get the type correct. 11184 return [[(GPBBoolUInt32Dictionary*)[self alloc] initWithValues:&value 11185 forKeys:&key 11186 count:1] autorelease]; 11187 } 11188 11189 + (instancetype)dictionaryWithValues:(const uint32_t [])values 11190 forKeys:(const BOOL [])keys 11191 count:(NSUInteger)count { 11192 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 11193 // on to get the type correct. 11194 return [[(GPBBoolUInt32Dictionary*)[self alloc] initWithValues:values 11195 forKeys:keys 11196 count:count] autorelease]; 11197 } 11198 11199 + (instancetype)dictionaryWithDictionary:(GPBBoolUInt32Dictionary *)dictionary { 11200 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 11201 // on to get the type correct. 11202 return [[(GPBBoolUInt32Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 11203 } 11204 11205 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 11206 return [[[self alloc] initWithCapacity:numItems] autorelease]; 11207 } 11208 11209 - (instancetype)init { 11210 return [self initWithValues:NULL forKeys:NULL count:0]; 11211 } 11212 11213 - (instancetype)initWithValues:(const uint32_t [])values 11214 forKeys:(const BOOL [])keys 11215 count:(NSUInteger)count { 11216 self = [super init]; 11217 if (self) { 11218 for (NSUInteger i = 0; i < count; ++i) { 11219 int idx = keys[i] ? 1 : 0; 11220 _values[idx] = values[i]; 11221 _valueSet[idx] = YES; 11222 } 11223 } 11224 return self; 11225 } 11226 11227 - (instancetype)initWithDictionary:(GPBBoolUInt32Dictionary *)dictionary { 11228 self = [self initWithValues:NULL forKeys:NULL count:0]; 11229 if (self) { 11230 if (dictionary) { 11231 for (int i = 0; i < 2; ++i) { 11232 if (dictionary->_valueSet[i]) { 11233 _values[i] = dictionary->_values[i]; 11234 _valueSet[i] = YES; 11235 } 11236 } 11237 } 11238 } 11239 return self; 11240 } 11241 11242 - (instancetype)initWithCapacity:(NSUInteger)numItems { 11243 #pragma unused(numItems) 11244 return [self initWithValues:NULL forKeys:NULL count:0]; 11245 } 11246 11247 #if !defined(NS_BLOCK_ASSERTIONS) 11248 - (void)dealloc { 11249 NSAssert(!_autocreator, 11250 @"%@: Autocreator must be cleared before release, autocreator: %@", 11251 [self class], _autocreator); 11252 [super dealloc]; 11253 } 11254 #endif // !defined(NS_BLOCK_ASSERTIONS) 11255 11256 - (instancetype)copyWithZone:(NSZone *)zone { 11257 return [[GPBBoolUInt32Dictionary allocWithZone:zone] initWithDictionary:self]; 11258 } 11259 11260 - (BOOL)isEqual:(GPBBoolUInt32Dictionary *)other { 11261 if (self == other) { 11262 return YES; 11263 } 11264 if (![other isKindOfClass:[GPBBoolUInt32Dictionary class]]) { 11265 return NO; 11266 } 11267 if ((_valueSet[0] != other->_valueSet[0]) || 11268 (_valueSet[1] != other->_valueSet[1])) { 11269 return NO; 11270 } 11271 if ((_valueSet[0] && (_values[0] != other->_values[0])) || 11272 (_valueSet[1] && (_values[1] != other->_values[1]))) { 11273 return NO; 11274 } 11275 return YES; 11276 } 11277 11278 - (NSUInteger)hash { 11279 return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0); 11280 } 11281 11282 - (NSString *)description { 11283 NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> {", [self class], self]; 11284 if (_valueSet[0]) { 11285 [result appendFormat:@"NO: %u", _values[0]]; 11286 } 11287 if (_valueSet[1]) { 11288 [result appendFormat:@"YES: %u", _values[1]]; 11289 } 11290 [result appendString:@" }"]; 11291 return result; 11292 } 11293 11294 - (NSUInteger)count { 11295 return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0); 11296 } 11297 11298 - (BOOL)valueForKey:(BOOL)key value:(uint32_t *)value { 11299 int idx = (key ? 1 : 0); 11300 if (_valueSet[idx]) { 11301 if (value) { 11302 *value = _values[idx]; 11303 } 11304 return YES; 11305 } 11306 return NO; 11307 } 11308 11309 - (void)setGPBGenericValue:(GPBGenericValue *)value 11310 forGPBGenericValueKey:(GPBGenericValue *)key { 11311 int idx = (key->valueBool ? 1 : 0); 11312 _values[idx] = value->valueUInt32; 11313 _valueSet[idx] = YES; 11314 } 11315 11316 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 11317 if (_valueSet[0]) { 11318 block(@"false", [NSString stringWithFormat:@"%u", _values[0]]); 11319 } 11320 if (_valueSet[1]) { 11321 block(@"true", [NSString stringWithFormat:@"%u", _values[1]]); 11322 } 11323 } 11324 11325 - (void)enumerateKeysAndValuesUsingBlock: 11326 (void (^)(BOOL key, uint32_t value, BOOL *stop))block { 11327 BOOL stop = NO; 11328 if (_valueSet[0]) { 11329 block(NO, _values[0], &stop); 11330 } 11331 if (!stop && _valueSet[1]) { 11332 block(YES, _values[1], &stop); 11333 } 11334 } 11335 11336 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 11337 GPBDataType valueDataType = GPBGetFieldDataType(field); 11338 NSUInteger count = 0; 11339 size_t result = 0; 11340 for (int i = 0; i < 2; ++i) { 11341 if (_valueSet[i]) { 11342 ++count; 11343 size_t msgSize = ComputeDictBoolFieldSize((i == 1), kMapKeyFieldNumber, GPBDataTypeBool); 11344 msgSize += ComputeDictUInt32FieldSize(_values[i], kMapValueFieldNumber, valueDataType); 11345 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 11346 } 11347 } 11348 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 11349 result += tagSize * count; 11350 return result; 11351 } 11352 11353 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 11354 asField:(GPBFieldDescriptor *)field { 11355 GPBDataType valueDataType = GPBGetFieldDataType(field); 11356 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 11357 for (int i = 0; i < 2; ++i) { 11358 if (_valueSet[i]) { 11359 // Write the tag. 11360 [outputStream writeInt32NoTag:tag]; 11361 // Write the size of the message. 11362 size_t msgSize = ComputeDictBoolFieldSize((i == 1), kMapKeyFieldNumber, GPBDataTypeBool); 11363 msgSize += ComputeDictUInt32FieldSize(_values[i], kMapValueFieldNumber, valueDataType); 11364 [outputStream writeInt32NoTag:(int32_t)msgSize]; 11365 // Write the fields. 11366 WriteDictBoolField(outputStream, (i == 1), kMapKeyFieldNumber, GPBDataTypeBool); 11367 WriteDictUInt32Field(outputStream, _values[i], kMapValueFieldNumber, valueDataType); 11368 } 11369 } 11370 } 11371 11372 - (void)addEntriesFromDictionary:(GPBBoolUInt32Dictionary *)otherDictionary { 11373 if (otherDictionary) { 11374 for (int i = 0; i < 2; ++i) { 11375 if (otherDictionary->_valueSet[i]) { 11376 _valueSet[i] = YES; 11377 _values[i] = otherDictionary->_values[i]; 11378 } 11379 } 11380 if (_autocreator) { 11381 GPBAutocreatedDictionaryModified(_autocreator, self); 11382 } 11383 } 11384 } 11385 11386 - (void)setValue:(uint32_t)value forKey:(BOOL)key { 11387 int idx = (key ? 1 : 0); 11388 _values[idx] = value; 11389 _valueSet[idx] = YES; 11390 if (_autocreator) { 11391 GPBAutocreatedDictionaryModified(_autocreator, self); 11392 } 11393 } 11394 11395 - (void)removeValueForKey:(BOOL)aKey { 11396 _valueSet[aKey ? 1 : 0] = NO; 11397 } 11398 11399 - (void)removeAll { 11400 _valueSet[0] = NO; 11401 _valueSet[1] = NO; 11402 } 11403 11404 @end 11405 11406 //%PDDM-EXPAND DICTIONARY_BOOL_KEY_TO_POD_IMPL(Int32, int32_t) 11407 // This block of code is generated, do not edit it directly. 11408 11409 #pragma mark - Bool -> Int32 11410 11411 @implementation GPBBoolInt32Dictionary { 11412 @package 11413 int32_t _values[2]; 11414 BOOL _valueSet[2]; 11415 } 11416 11417 + (instancetype)dictionary { 11418 return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; 11419 } 11420 11421 + (instancetype)dictionaryWithValue:(int32_t)value 11422 forKey:(BOOL)key { 11423 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 11424 // on to get the type correct. 11425 return [[(GPBBoolInt32Dictionary*)[self alloc] initWithValues:&value 11426 forKeys:&key 11427 count:1] autorelease]; 11428 } 11429 11430 + (instancetype)dictionaryWithValues:(const int32_t [])values 11431 forKeys:(const BOOL [])keys 11432 count:(NSUInteger)count { 11433 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 11434 // on to get the type correct. 11435 return [[(GPBBoolInt32Dictionary*)[self alloc] initWithValues:values 11436 forKeys:keys 11437 count:count] autorelease]; 11438 } 11439 11440 + (instancetype)dictionaryWithDictionary:(GPBBoolInt32Dictionary *)dictionary { 11441 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 11442 // on to get the type correct. 11443 return [[(GPBBoolInt32Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 11444 } 11445 11446 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 11447 return [[[self alloc] initWithCapacity:numItems] autorelease]; 11448 } 11449 11450 - (instancetype)init { 11451 return [self initWithValues:NULL forKeys:NULL count:0]; 11452 } 11453 11454 - (instancetype)initWithValues:(const int32_t [])values 11455 forKeys:(const BOOL [])keys 11456 count:(NSUInteger)count { 11457 self = [super init]; 11458 if (self) { 11459 for (NSUInteger i = 0; i < count; ++i) { 11460 int idx = keys[i] ? 1 : 0; 11461 _values[idx] = values[i]; 11462 _valueSet[idx] = YES; 11463 } 11464 } 11465 return self; 11466 } 11467 11468 - (instancetype)initWithDictionary:(GPBBoolInt32Dictionary *)dictionary { 11469 self = [self initWithValues:NULL forKeys:NULL count:0]; 11470 if (self) { 11471 if (dictionary) { 11472 for (int i = 0; i < 2; ++i) { 11473 if (dictionary->_valueSet[i]) { 11474 _values[i] = dictionary->_values[i]; 11475 _valueSet[i] = YES; 11476 } 11477 } 11478 } 11479 } 11480 return self; 11481 } 11482 11483 - (instancetype)initWithCapacity:(NSUInteger)numItems { 11484 #pragma unused(numItems) 11485 return [self initWithValues:NULL forKeys:NULL count:0]; 11486 } 11487 11488 #if !defined(NS_BLOCK_ASSERTIONS) 11489 - (void)dealloc { 11490 NSAssert(!_autocreator, 11491 @"%@: Autocreator must be cleared before release, autocreator: %@", 11492 [self class], _autocreator); 11493 [super dealloc]; 11494 } 11495 #endif // !defined(NS_BLOCK_ASSERTIONS) 11496 11497 - (instancetype)copyWithZone:(NSZone *)zone { 11498 return [[GPBBoolInt32Dictionary allocWithZone:zone] initWithDictionary:self]; 11499 } 11500 11501 - (BOOL)isEqual:(GPBBoolInt32Dictionary *)other { 11502 if (self == other) { 11503 return YES; 11504 } 11505 if (![other isKindOfClass:[GPBBoolInt32Dictionary class]]) { 11506 return NO; 11507 } 11508 if ((_valueSet[0] != other->_valueSet[0]) || 11509 (_valueSet[1] != other->_valueSet[1])) { 11510 return NO; 11511 } 11512 if ((_valueSet[0] && (_values[0] != other->_values[0])) || 11513 (_valueSet[1] && (_values[1] != other->_values[1]))) { 11514 return NO; 11515 } 11516 return YES; 11517 } 11518 11519 - (NSUInteger)hash { 11520 return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0); 11521 } 11522 11523 - (NSString *)description { 11524 NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> {", [self class], self]; 11525 if (_valueSet[0]) { 11526 [result appendFormat:@"NO: %d", _values[0]]; 11527 } 11528 if (_valueSet[1]) { 11529 [result appendFormat:@"YES: %d", _values[1]]; 11530 } 11531 [result appendString:@" }"]; 11532 return result; 11533 } 11534 11535 - (NSUInteger)count { 11536 return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0); 11537 } 11538 11539 - (BOOL)valueForKey:(BOOL)key value:(int32_t *)value { 11540 int idx = (key ? 1 : 0); 11541 if (_valueSet[idx]) { 11542 if (value) { 11543 *value = _values[idx]; 11544 } 11545 return YES; 11546 } 11547 return NO; 11548 } 11549 11550 - (void)setGPBGenericValue:(GPBGenericValue *)value 11551 forGPBGenericValueKey:(GPBGenericValue *)key { 11552 int idx = (key->valueBool ? 1 : 0); 11553 _values[idx] = value->valueInt32; 11554 _valueSet[idx] = YES; 11555 } 11556 11557 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 11558 if (_valueSet[0]) { 11559 block(@"false", [NSString stringWithFormat:@"%d", _values[0]]); 11560 } 11561 if (_valueSet[1]) { 11562 block(@"true", [NSString stringWithFormat:@"%d", _values[1]]); 11563 } 11564 } 11565 11566 - (void)enumerateKeysAndValuesUsingBlock: 11567 (void (^)(BOOL key, int32_t value, BOOL *stop))block { 11568 BOOL stop = NO; 11569 if (_valueSet[0]) { 11570 block(NO, _values[0], &stop); 11571 } 11572 if (!stop && _valueSet[1]) { 11573 block(YES, _values[1], &stop); 11574 } 11575 } 11576 11577 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 11578 GPBDataType valueDataType = GPBGetFieldDataType(field); 11579 NSUInteger count = 0; 11580 size_t result = 0; 11581 for (int i = 0; i < 2; ++i) { 11582 if (_valueSet[i]) { 11583 ++count; 11584 size_t msgSize = ComputeDictBoolFieldSize((i == 1), kMapKeyFieldNumber, GPBDataTypeBool); 11585 msgSize += ComputeDictInt32FieldSize(_values[i], kMapValueFieldNumber, valueDataType); 11586 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 11587 } 11588 } 11589 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 11590 result += tagSize * count; 11591 return result; 11592 } 11593 11594 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 11595 asField:(GPBFieldDescriptor *)field { 11596 GPBDataType valueDataType = GPBGetFieldDataType(field); 11597 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 11598 for (int i = 0; i < 2; ++i) { 11599 if (_valueSet[i]) { 11600 // Write the tag. 11601 [outputStream writeInt32NoTag:tag]; 11602 // Write the size of the message. 11603 size_t msgSize = ComputeDictBoolFieldSize((i == 1), kMapKeyFieldNumber, GPBDataTypeBool); 11604 msgSize += ComputeDictInt32FieldSize(_values[i], kMapValueFieldNumber, valueDataType); 11605 [outputStream writeInt32NoTag:(int32_t)msgSize]; 11606 // Write the fields. 11607 WriteDictBoolField(outputStream, (i == 1), kMapKeyFieldNumber, GPBDataTypeBool); 11608 WriteDictInt32Field(outputStream, _values[i], kMapValueFieldNumber, valueDataType); 11609 } 11610 } 11611 } 11612 11613 - (void)addEntriesFromDictionary:(GPBBoolInt32Dictionary *)otherDictionary { 11614 if (otherDictionary) { 11615 for (int i = 0; i < 2; ++i) { 11616 if (otherDictionary->_valueSet[i]) { 11617 _valueSet[i] = YES; 11618 _values[i] = otherDictionary->_values[i]; 11619 } 11620 } 11621 if (_autocreator) { 11622 GPBAutocreatedDictionaryModified(_autocreator, self); 11623 } 11624 } 11625 } 11626 11627 - (void)setValue:(int32_t)value forKey:(BOOL)key { 11628 int idx = (key ? 1 : 0); 11629 _values[idx] = value; 11630 _valueSet[idx] = YES; 11631 if (_autocreator) { 11632 GPBAutocreatedDictionaryModified(_autocreator, self); 11633 } 11634 } 11635 11636 - (void)removeValueForKey:(BOOL)aKey { 11637 _valueSet[aKey ? 1 : 0] = NO; 11638 } 11639 11640 - (void)removeAll { 11641 _valueSet[0] = NO; 11642 _valueSet[1] = NO; 11643 } 11644 11645 @end 11646 11647 //%PDDM-EXPAND DICTIONARY_BOOL_KEY_TO_POD_IMPL(UInt64, uint64_t) 11648 // This block of code is generated, do not edit it directly. 11649 11650 #pragma mark - Bool -> UInt64 11651 11652 @implementation GPBBoolUInt64Dictionary { 11653 @package 11654 uint64_t _values[2]; 11655 BOOL _valueSet[2]; 11656 } 11657 11658 + (instancetype)dictionary { 11659 return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; 11660 } 11661 11662 + (instancetype)dictionaryWithValue:(uint64_t)value 11663 forKey:(BOOL)key { 11664 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 11665 // on to get the type correct. 11666 return [[(GPBBoolUInt64Dictionary*)[self alloc] initWithValues:&value 11667 forKeys:&key 11668 count:1] autorelease]; 11669 } 11670 11671 + (instancetype)dictionaryWithValues:(const uint64_t [])values 11672 forKeys:(const BOOL [])keys 11673 count:(NSUInteger)count { 11674 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 11675 // on to get the type correct. 11676 return [[(GPBBoolUInt64Dictionary*)[self alloc] initWithValues:values 11677 forKeys:keys 11678 count:count] autorelease]; 11679 } 11680 11681 + (instancetype)dictionaryWithDictionary:(GPBBoolUInt64Dictionary *)dictionary { 11682 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 11683 // on to get the type correct. 11684 return [[(GPBBoolUInt64Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 11685 } 11686 11687 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 11688 return [[[self alloc] initWithCapacity:numItems] autorelease]; 11689 } 11690 11691 - (instancetype)init { 11692 return [self initWithValues:NULL forKeys:NULL count:0]; 11693 } 11694 11695 - (instancetype)initWithValues:(const uint64_t [])values 11696 forKeys:(const BOOL [])keys 11697 count:(NSUInteger)count { 11698 self = [super init]; 11699 if (self) { 11700 for (NSUInteger i = 0; i < count; ++i) { 11701 int idx = keys[i] ? 1 : 0; 11702 _values[idx] = values[i]; 11703 _valueSet[idx] = YES; 11704 } 11705 } 11706 return self; 11707 } 11708 11709 - (instancetype)initWithDictionary:(GPBBoolUInt64Dictionary *)dictionary { 11710 self = [self initWithValues:NULL forKeys:NULL count:0]; 11711 if (self) { 11712 if (dictionary) { 11713 for (int i = 0; i < 2; ++i) { 11714 if (dictionary->_valueSet[i]) { 11715 _values[i] = dictionary->_values[i]; 11716 _valueSet[i] = YES; 11717 } 11718 } 11719 } 11720 } 11721 return self; 11722 } 11723 11724 - (instancetype)initWithCapacity:(NSUInteger)numItems { 11725 #pragma unused(numItems) 11726 return [self initWithValues:NULL forKeys:NULL count:0]; 11727 } 11728 11729 #if !defined(NS_BLOCK_ASSERTIONS) 11730 - (void)dealloc { 11731 NSAssert(!_autocreator, 11732 @"%@: Autocreator must be cleared before release, autocreator: %@", 11733 [self class], _autocreator); 11734 [super dealloc]; 11735 } 11736 #endif // !defined(NS_BLOCK_ASSERTIONS) 11737 11738 - (instancetype)copyWithZone:(NSZone *)zone { 11739 return [[GPBBoolUInt64Dictionary allocWithZone:zone] initWithDictionary:self]; 11740 } 11741 11742 - (BOOL)isEqual:(GPBBoolUInt64Dictionary *)other { 11743 if (self == other) { 11744 return YES; 11745 } 11746 if (![other isKindOfClass:[GPBBoolUInt64Dictionary class]]) { 11747 return NO; 11748 } 11749 if ((_valueSet[0] != other->_valueSet[0]) || 11750 (_valueSet[1] != other->_valueSet[1])) { 11751 return NO; 11752 } 11753 if ((_valueSet[0] && (_values[0] != other->_values[0])) || 11754 (_valueSet[1] && (_values[1] != other->_values[1]))) { 11755 return NO; 11756 } 11757 return YES; 11758 } 11759 11760 - (NSUInteger)hash { 11761 return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0); 11762 } 11763 11764 - (NSString *)description { 11765 NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> {", [self class], self]; 11766 if (_valueSet[0]) { 11767 [result appendFormat:@"NO: %llu", _values[0]]; 11768 } 11769 if (_valueSet[1]) { 11770 [result appendFormat:@"YES: %llu", _values[1]]; 11771 } 11772 [result appendString:@" }"]; 11773 return result; 11774 } 11775 11776 - (NSUInteger)count { 11777 return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0); 11778 } 11779 11780 - (BOOL)valueForKey:(BOOL)key value:(uint64_t *)value { 11781 int idx = (key ? 1 : 0); 11782 if (_valueSet[idx]) { 11783 if (value) { 11784 *value = _values[idx]; 11785 } 11786 return YES; 11787 } 11788 return NO; 11789 } 11790 11791 - (void)setGPBGenericValue:(GPBGenericValue *)value 11792 forGPBGenericValueKey:(GPBGenericValue *)key { 11793 int idx = (key->valueBool ? 1 : 0); 11794 _values[idx] = value->valueUInt64; 11795 _valueSet[idx] = YES; 11796 } 11797 11798 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 11799 if (_valueSet[0]) { 11800 block(@"false", [NSString stringWithFormat:@"%llu", _values[0]]); 11801 } 11802 if (_valueSet[1]) { 11803 block(@"true", [NSString stringWithFormat:@"%llu", _values[1]]); 11804 } 11805 } 11806 11807 - (void)enumerateKeysAndValuesUsingBlock: 11808 (void (^)(BOOL key, uint64_t value, BOOL *stop))block { 11809 BOOL stop = NO; 11810 if (_valueSet[0]) { 11811 block(NO, _values[0], &stop); 11812 } 11813 if (!stop && _valueSet[1]) { 11814 block(YES, _values[1], &stop); 11815 } 11816 } 11817 11818 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 11819 GPBDataType valueDataType = GPBGetFieldDataType(field); 11820 NSUInteger count = 0; 11821 size_t result = 0; 11822 for (int i = 0; i < 2; ++i) { 11823 if (_valueSet[i]) { 11824 ++count; 11825 size_t msgSize = ComputeDictBoolFieldSize((i == 1), kMapKeyFieldNumber, GPBDataTypeBool); 11826 msgSize += ComputeDictUInt64FieldSize(_values[i], kMapValueFieldNumber, valueDataType); 11827 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 11828 } 11829 } 11830 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 11831 result += tagSize * count; 11832 return result; 11833 } 11834 11835 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 11836 asField:(GPBFieldDescriptor *)field { 11837 GPBDataType valueDataType = GPBGetFieldDataType(field); 11838 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 11839 for (int i = 0; i < 2; ++i) { 11840 if (_valueSet[i]) { 11841 // Write the tag. 11842 [outputStream writeInt32NoTag:tag]; 11843 // Write the size of the message. 11844 size_t msgSize = ComputeDictBoolFieldSize((i == 1), kMapKeyFieldNumber, GPBDataTypeBool); 11845 msgSize += ComputeDictUInt64FieldSize(_values[i], kMapValueFieldNumber, valueDataType); 11846 [outputStream writeInt32NoTag:(int32_t)msgSize]; 11847 // Write the fields. 11848 WriteDictBoolField(outputStream, (i == 1), kMapKeyFieldNumber, GPBDataTypeBool); 11849 WriteDictUInt64Field(outputStream, _values[i], kMapValueFieldNumber, valueDataType); 11850 } 11851 } 11852 } 11853 11854 - (void)addEntriesFromDictionary:(GPBBoolUInt64Dictionary *)otherDictionary { 11855 if (otherDictionary) { 11856 for (int i = 0; i < 2; ++i) { 11857 if (otherDictionary->_valueSet[i]) { 11858 _valueSet[i] = YES; 11859 _values[i] = otherDictionary->_values[i]; 11860 } 11861 } 11862 if (_autocreator) { 11863 GPBAutocreatedDictionaryModified(_autocreator, self); 11864 } 11865 } 11866 } 11867 11868 - (void)setValue:(uint64_t)value forKey:(BOOL)key { 11869 int idx = (key ? 1 : 0); 11870 _values[idx] = value; 11871 _valueSet[idx] = YES; 11872 if (_autocreator) { 11873 GPBAutocreatedDictionaryModified(_autocreator, self); 11874 } 11875 } 11876 11877 - (void)removeValueForKey:(BOOL)aKey { 11878 _valueSet[aKey ? 1 : 0] = NO; 11879 } 11880 11881 - (void)removeAll { 11882 _valueSet[0] = NO; 11883 _valueSet[1] = NO; 11884 } 11885 11886 @end 11887 11888 //%PDDM-EXPAND DICTIONARY_BOOL_KEY_TO_POD_IMPL(Int64, int64_t) 11889 // This block of code is generated, do not edit it directly. 11890 11891 #pragma mark - Bool -> Int64 11892 11893 @implementation GPBBoolInt64Dictionary { 11894 @package 11895 int64_t _values[2]; 11896 BOOL _valueSet[2]; 11897 } 11898 11899 + (instancetype)dictionary { 11900 return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; 11901 } 11902 11903 + (instancetype)dictionaryWithValue:(int64_t)value 11904 forKey:(BOOL)key { 11905 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 11906 // on to get the type correct. 11907 return [[(GPBBoolInt64Dictionary*)[self alloc] initWithValues:&value 11908 forKeys:&key 11909 count:1] autorelease]; 11910 } 11911 11912 + (instancetype)dictionaryWithValues:(const int64_t [])values 11913 forKeys:(const BOOL [])keys 11914 count:(NSUInteger)count { 11915 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 11916 // on to get the type correct. 11917 return [[(GPBBoolInt64Dictionary*)[self alloc] initWithValues:values 11918 forKeys:keys 11919 count:count] autorelease]; 11920 } 11921 11922 + (instancetype)dictionaryWithDictionary:(GPBBoolInt64Dictionary *)dictionary { 11923 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 11924 // on to get the type correct. 11925 return [[(GPBBoolInt64Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 11926 } 11927 11928 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 11929 return [[[self alloc] initWithCapacity:numItems] autorelease]; 11930 } 11931 11932 - (instancetype)init { 11933 return [self initWithValues:NULL forKeys:NULL count:0]; 11934 } 11935 11936 - (instancetype)initWithValues:(const int64_t [])values 11937 forKeys:(const BOOL [])keys 11938 count:(NSUInteger)count { 11939 self = [super init]; 11940 if (self) { 11941 for (NSUInteger i = 0; i < count; ++i) { 11942 int idx = keys[i] ? 1 : 0; 11943 _values[idx] = values[i]; 11944 _valueSet[idx] = YES; 11945 } 11946 } 11947 return self; 11948 } 11949 11950 - (instancetype)initWithDictionary:(GPBBoolInt64Dictionary *)dictionary { 11951 self = [self initWithValues:NULL forKeys:NULL count:0]; 11952 if (self) { 11953 if (dictionary) { 11954 for (int i = 0; i < 2; ++i) { 11955 if (dictionary->_valueSet[i]) { 11956 _values[i] = dictionary->_values[i]; 11957 _valueSet[i] = YES; 11958 } 11959 } 11960 } 11961 } 11962 return self; 11963 } 11964 11965 - (instancetype)initWithCapacity:(NSUInteger)numItems { 11966 #pragma unused(numItems) 11967 return [self initWithValues:NULL forKeys:NULL count:0]; 11968 } 11969 11970 #if !defined(NS_BLOCK_ASSERTIONS) 11971 - (void)dealloc { 11972 NSAssert(!_autocreator, 11973 @"%@: Autocreator must be cleared before release, autocreator: %@", 11974 [self class], _autocreator); 11975 [super dealloc]; 11976 } 11977 #endif // !defined(NS_BLOCK_ASSERTIONS) 11978 11979 - (instancetype)copyWithZone:(NSZone *)zone { 11980 return [[GPBBoolInt64Dictionary allocWithZone:zone] initWithDictionary:self]; 11981 } 11982 11983 - (BOOL)isEqual:(GPBBoolInt64Dictionary *)other { 11984 if (self == other) { 11985 return YES; 11986 } 11987 if (![other isKindOfClass:[GPBBoolInt64Dictionary class]]) { 11988 return NO; 11989 } 11990 if ((_valueSet[0] != other->_valueSet[0]) || 11991 (_valueSet[1] != other->_valueSet[1])) { 11992 return NO; 11993 } 11994 if ((_valueSet[0] && (_values[0] != other->_values[0])) || 11995 (_valueSet[1] && (_values[1] != other->_values[1]))) { 11996 return NO; 11997 } 11998 return YES; 11999 } 12000 12001 - (NSUInteger)hash { 12002 return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0); 12003 } 12004 12005 - (NSString *)description { 12006 NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> {", [self class], self]; 12007 if (_valueSet[0]) { 12008 [result appendFormat:@"NO: %lld", _values[0]]; 12009 } 12010 if (_valueSet[1]) { 12011 [result appendFormat:@"YES: %lld", _values[1]]; 12012 } 12013 [result appendString:@" }"]; 12014 return result; 12015 } 12016 12017 - (NSUInteger)count { 12018 return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0); 12019 } 12020 12021 - (BOOL)valueForKey:(BOOL)key value:(int64_t *)value { 12022 int idx = (key ? 1 : 0); 12023 if (_valueSet[idx]) { 12024 if (value) { 12025 *value = _values[idx]; 12026 } 12027 return YES; 12028 } 12029 return NO; 12030 } 12031 12032 - (void)setGPBGenericValue:(GPBGenericValue *)value 12033 forGPBGenericValueKey:(GPBGenericValue *)key { 12034 int idx = (key->valueBool ? 1 : 0); 12035 _values[idx] = value->valueInt64; 12036 _valueSet[idx] = YES; 12037 } 12038 12039 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 12040 if (_valueSet[0]) { 12041 block(@"false", [NSString stringWithFormat:@"%lld", _values[0]]); 12042 } 12043 if (_valueSet[1]) { 12044 block(@"true", [NSString stringWithFormat:@"%lld", _values[1]]); 12045 } 12046 } 12047 12048 - (void)enumerateKeysAndValuesUsingBlock: 12049 (void (^)(BOOL key, int64_t value, BOOL *stop))block { 12050 BOOL stop = NO; 12051 if (_valueSet[0]) { 12052 block(NO, _values[0], &stop); 12053 } 12054 if (!stop && _valueSet[1]) { 12055 block(YES, _values[1], &stop); 12056 } 12057 } 12058 12059 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 12060 GPBDataType valueDataType = GPBGetFieldDataType(field); 12061 NSUInteger count = 0; 12062 size_t result = 0; 12063 for (int i = 0; i < 2; ++i) { 12064 if (_valueSet[i]) { 12065 ++count; 12066 size_t msgSize = ComputeDictBoolFieldSize((i == 1), kMapKeyFieldNumber, GPBDataTypeBool); 12067 msgSize += ComputeDictInt64FieldSize(_values[i], kMapValueFieldNumber, valueDataType); 12068 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 12069 } 12070 } 12071 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 12072 result += tagSize * count; 12073 return result; 12074 } 12075 12076 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 12077 asField:(GPBFieldDescriptor *)field { 12078 GPBDataType valueDataType = GPBGetFieldDataType(field); 12079 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 12080 for (int i = 0; i < 2; ++i) { 12081 if (_valueSet[i]) { 12082 // Write the tag. 12083 [outputStream writeInt32NoTag:tag]; 12084 // Write the size of the message. 12085 size_t msgSize = ComputeDictBoolFieldSize((i == 1), kMapKeyFieldNumber, GPBDataTypeBool); 12086 msgSize += ComputeDictInt64FieldSize(_values[i], kMapValueFieldNumber, valueDataType); 12087 [outputStream writeInt32NoTag:(int32_t)msgSize]; 12088 // Write the fields. 12089 WriteDictBoolField(outputStream, (i == 1), kMapKeyFieldNumber, GPBDataTypeBool); 12090 WriteDictInt64Field(outputStream, _values[i], kMapValueFieldNumber, valueDataType); 12091 } 12092 } 12093 } 12094 12095 - (void)addEntriesFromDictionary:(GPBBoolInt64Dictionary *)otherDictionary { 12096 if (otherDictionary) { 12097 for (int i = 0; i < 2; ++i) { 12098 if (otherDictionary->_valueSet[i]) { 12099 _valueSet[i] = YES; 12100 _values[i] = otherDictionary->_values[i]; 12101 } 12102 } 12103 if (_autocreator) { 12104 GPBAutocreatedDictionaryModified(_autocreator, self); 12105 } 12106 } 12107 } 12108 12109 - (void)setValue:(int64_t)value forKey:(BOOL)key { 12110 int idx = (key ? 1 : 0); 12111 _values[idx] = value; 12112 _valueSet[idx] = YES; 12113 if (_autocreator) { 12114 GPBAutocreatedDictionaryModified(_autocreator, self); 12115 } 12116 } 12117 12118 - (void)removeValueForKey:(BOOL)aKey { 12119 _valueSet[aKey ? 1 : 0] = NO; 12120 } 12121 12122 - (void)removeAll { 12123 _valueSet[0] = NO; 12124 _valueSet[1] = NO; 12125 } 12126 12127 @end 12128 12129 //%PDDM-EXPAND DICTIONARY_BOOL_KEY_TO_POD_IMPL(Bool, BOOL) 12130 // This block of code is generated, do not edit it directly. 12131 12132 #pragma mark - Bool -> Bool 12133 12134 @implementation GPBBoolBoolDictionary { 12135 @package 12136 BOOL _values[2]; 12137 BOOL _valueSet[2]; 12138 } 12139 12140 + (instancetype)dictionary { 12141 return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; 12142 } 12143 12144 + (instancetype)dictionaryWithValue:(BOOL)value 12145 forKey:(BOOL)key { 12146 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 12147 // on to get the type correct. 12148 return [[(GPBBoolBoolDictionary*)[self alloc] initWithValues:&value 12149 forKeys:&key 12150 count:1] autorelease]; 12151 } 12152 12153 + (instancetype)dictionaryWithValues:(const BOOL [])values 12154 forKeys:(const BOOL [])keys 12155 count:(NSUInteger)count { 12156 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 12157 // on to get the type correct. 12158 return [[(GPBBoolBoolDictionary*)[self alloc] initWithValues:values 12159 forKeys:keys 12160 count:count] autorelease]; 12161 } 12162 12163 + (instancetype)dictionaryWithDictionary:(GPBBoolBoolDictionary *)dictionary { 12164 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 12165 // on to get the type correct. 12166 return [[(GPBBoolBoolDictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 12167 } 12168 12169 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 12170 return [[[self alloc] initWithCapacity:numItems] autorelease]; 12171 } 12172 12173 - (instancetype)init { 12174 return [self initWithValues:NULL forKeys:NULL count:0]; 12175 } 12176 12177 - (instancetype)initWithValues:(const BOOL [])values 12178 forKeys:(const BOOL [])keys 12179 count:(NSUInteger)count { 12180 self = [super init]; 12181 if (self) { 12182 for (NSUInteger i = 0; i < count; ++i) { 12183 int idx = keys[i] ? 1 : 0; 12184 _values[idx] = values[i]; 12185 _valueSet[idx] = YES; 12186 } 12187 } 12188 return self; 12189 } 12190 12191 - (instancetype)initWithDictionary:(GPBBoolBoolDictionary *)dictionary { 12192 self = [self initWithValues:NULL forKeys:NULL count:0]; 12193 if (self) { 12194 if (dictionary) { 12195 for (int i = 0; i < 2; ++i) { 12196 if (dictionary->_valueSet[i]) { 12197 _values[i] = dictionary->_values[i]; 12198 _valueSet[i] = YES; 12199 } 12200 } 12201 } 12202 } 12203 return self; 12204 } 12205 12206 - (instancetype)initWithCapacity:(NSUInteger)numItems { 12207 #pragma unused(numItems) 12208 return [self initWithValues:NULL forKeys:NULL count:0]; 12209 } 12210 12211 #if !defined(NS_BLOCK_ASSERTIONS) 12212 - (void)dealloc { 12213 NSAssert(!_autocreator, 12214 @"%@: Autocreator must be cleared before release, autocreator: %@", 12215 [self class], _autocreator); 12216 [super dealloc]; 12217 } 12218 #endif // !defined(NS_BLOCK_ASSERTIONS) 12219 12220 - (instancetype)copyWithZone:(NSZone *)zone { 12221 return [[GPBBoolBoolDictionary allocWithZone:zone] initWithDictionary:self]; 12222 } 12223 12224 - (BOOL)isEqual:(GPBBoolBoolDictionary *)other { 12225 if (self == other) { 12226 return YES; 12227 } 12228 if (![other isKindOfClass:[GPBBoolBoolDictionary class]]) { 12229 return NO; 12230 } 12231 if ((_valueSet[0] != other->_valueSet[0]) || 12232 (_valueSet[1] != other->_valueSet[1])) { 12233 return NO; 12234 } 12235 if ((_valueSet[0] && (_values[0] != other->_values[0])) || 12236 (_valueSet[1] && (_values[1] != other->_values[1]))) { 12237 return NO; 12238 } 12239 return YES; 12240 } 12241 12242 - (NSUInteger)hash { 12243 return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0); 12244 } 12245 12246 - (NSString *)description { 12247 NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> {", [self class], self]; 12248 if (_valueSet[0]) { 12249 [result appendFormat:@"NO: %d", _values[0]]; 12250 } 12251 if (_valueSet[1]) { 12252 [result appendFormat:@"YES: %d", _values[1]]; 12253 } 12254 [result appendString:@" }"]; 12255 return result; 12256 } 12257 12258 - (NSUInteger)count { 12259 return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0); 12260 } 12261 12262 - (BOOL)valueForKey:(BOOL)key value:(BOOL *)value { 12263 int idx = (key ? 1 : 0); 12264 if (_valueSet[idx]) { 12265 if (value) { 12266 *value = _values[idx]; 12267 } 12268 return YES; 12269 } 12270 return NO; 12271 } 12272 12273 - (void)setGPBGenericValue:(GPBGenericValue *)value 12274 forGPBGenericValueKey:(GPBGenericValue *)key { 12275 int idx = (key->valueBool ? 1 : 0); 12276 _values[idx] = value->valueBool; 12277 _valueSet[idx] = YES; 12278 } 12279 12280 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 12281 if (_valueSet[0]) { 12282 block(@"false", (_values[0] ? @"true" : @"false")); 12283 } 12284 if (_valueSet[1]) { 12285 block(@"true", (_values[1] ? @"true" : @"false")); 12286 } 12287 } 12288 12289 - (void)enumerateKeysAndValuesUsingBlock: 12290 (void (^)(BOOL key, BOOL value, BOOL *stop))block { 12291 BOOL stop = NO; 12292 if (_valueSet[0]) { 12293 block(NO, _values[0], &stop); 12294 } 12295 if (!stop && _valueSet[1]) { 12296 block(YES, _values[1], &stop); 12297 } 12298 } 12299 12300 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 12301 GPBDataType valueDataType = GPBGetFieldDataType(field); 12302 NSUInteger count = 0; 12303 size_t result = 0; 12304 for (int i = 0; i < 2; ++i) { 12305 if (_valueSet[i]) { 12306 ++count; 12307 size_t msgSize = ComputeDictBoolFieldSize((i == 1), kMapKeyFieldNumber, GPBDataTypeBool); 12308 msgSize += ComputeDictBoolFieldSize(_values[i], kMapValueFieldNumber, valueDataType); 12309 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 12310 } 12311 } 12312 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 12313 result += tagSize * count; 12314 return result; 12315 } 12316 12317 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 12318 asField:(GPBFieldDescriptor *)field { 12319 GPBDataType valueDataType = GPBGetFieldDataType(field); 12320 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 12321 for (int i = 0; i < 2; ++i) { 12322 if (_valueSet[i]) { 12323 // Write the tag. 12324 [outputStream writeInt32NoTag:tag]; 12325 // Write the size of the message. 12326 size_t msgSize = ComputeDictBoolFieldSize((i == 1), kMapKeyFieldNumber, GPBDataTypeBool); 12327 msgSize += ComputeDictBoolFieldSize(_values[i], kMapValueFieldNumber, valueDataType); 12328 [outputStream writeInt32NoTag:(int32_t)msgSize]; 12329 // Write the fields. 12330 WriteDictBoolField(outputStream, (i == 1), kMapKeyFieldNumber, GPBDataTypeBool); 12331 WriteDictBoolField(outputStream, _values[i], kMapValueFieldNumber, valueDataType); 12332 } 12333 } 12334 } 12335 12336 - (void)addEntriesFromDictionary:(GPBBoolBoolDictionary *)otherDictionary { 12337 if (otherDictionary) { 12338 for (int i = 0; i < 2; ++i) { 12339 if (otherDictionary->_valueSet[i]) { 12340 _valueSet[i] = YES; 12341 _values[i] = otherDictionary->_values[i]; 12342 } 12343 } 12344 if (_autocreator) { 12345 GPBAutocreatedDictionaryModified(_autocreator, self); 12346 } 12347 } 12348 } 12349 12350 - (void)setValue:(BOOL)value forKey:(BOOL)key { 12351 int idx = (key ? 1 : 0); 12352 _values[idx] = value; 12353 _valueSet[idx] = YES; 12354 if (_autocreator) { 12355 GPBAutocreatedDictionaryModified(_autocreator, self); 12356 } 12357 } 12358 12359 - (void)removeValueForKey:(BOOL)aKey { 12360 _valueSet[aKey ? 1 : 0] = NO; 12361 } 12362 12363 - (void)removeAll { 12364 _valueSet[0] = NO; 12365 _valueSet[1] = NO; 12366 } 12367 12368 @end 12369 12370 //%PDDM-EXPAND DICTIONARY_BOOL_KEY_TO_POD_IMPL(Float, float) 12371 // This block of code is generated, do not edit it directly. 12372 12373 #pragma mark - Bool -> Float 12374 12375 @implementation GPBBoolFloatDictionary { 12376 @package 12377 float _values[2]; 12378 BOOL _valueSet[2]; 12379 } 12380 12381 + (instancetype)dictionary { 12382 return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; 12383 } 12384 12385 + (instancetype)dictionaryWithValue:(float)value 12386 forKey:(BOOL)key { 12387 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 12388 // on to get the type correct. 12389 return [[(GPBBoolFloatDictionary*)[self alloc] initWithValues:&value 12390 forKeys:&key 12391 count:1] autorelease]; 12392 } 12393 12394 + (instancetype)dictionaryWithValues:(const float [])values 12395 forKeys:(const BOOL [])keys 12396 count:(NSUInteger)count { 12397 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 12398 // on to get the type correct. 12399 return [[(GPBBoolFloatDictionary*)[self alloc] initWithValues:values 12400 forKeys:keys 12401 count:count] autorelease]; 12402 } 12403 12404 + (instancetype)dictionaryWithDictionary:(GPBBoolFloatDictionary *)dictionary { 12405 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 12406 // on to get the type correct. 12407 return [[(GPBBoolFloatDictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 12408 } 12409 12410 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 12411 return [[[self alloc] initWithCapacity:numItems] autorelease]; 12412 } 12413 12414 - (instancetype)init { 12415 return [self initWithValues:NULL forKeys:NULL count:0]; 12416 } 12417 12418 - (instancetype)initWithValues:(const float [])values 12419 forKeys:(const BOOL [])keys 12420 count:(NSUInteger)count { 12421 self = [super init]; 12422 if (self) { 12423 for (NSUInteger i = 0; i < count; ++i) { 12424 int idx = keys[i] ? 1 : 0; 12425 _values[idx] = values[i]; 12426 _valueSet[idx] = YES; 12427 } 12428 } 12429 return self; 12430 } 12431 12432 - (instancetype)initWithDictionary:(GPBBoolFloatDictionary *)dictionary { 12433 self = [self initWithValues:NULL forKeys:NULL count:0]; 12434 if (self) { 12435 if (dictionary) { 12436 for (int i = 0; i < 2; ++i) { 12437 if (dictionary->_valueSet[i]) { 12438 _values[i] = dictionary->_values[i]; 12439 _valueSet[i] = YES; 12440 } 12441 } 12442 } 12443 } 12444 return self; 12445 } 12446 12447 - (instancetype)initWithCapacity:(NSUInteger)numItems { 12448 #pragma unused(numItems) 12449 return [self initWithValues:NULL forKeys:NULL count:0]; 12450 } 12451 12452 #if !defined(NS_BLOCK_ASSERTIONS) 12453 - (void)dealloc { 12454 NSAssert(!_autocreator, 12455 @"%@: Autocreator must be cleared before release, autocreator: %@", 12456 [self class], _autocreator); 12457 [super dealloc]; 12458 } 12459 #endif // !defined(NS_BLOCK_ASSERTIONS) 12460 12461 - (instancetype)copyWithZone:(NSZone *)zone { 12462 return [[GPBBoolFloatDictionary allocWithZone:zone] initWithDictionary:self]; 12463 } 12464 12465 - (BOOL)isEqual:(GPBBoolFloatDictionary *)other { 12466 if (self == other) { 12467 return YES; 12468 } 12469 if (![other isKindOfClass:[GPBBoolFloatDictionary class]]) { 12470 return NO; 12471 } 12472 if ((_valueSet[0] != other->_valueSet[0]) || 12473 (_valueSet[1] != other->_valueSet[1])) { 12474 return NO; 12475 } 12476 if ((_valueSet[0] && (_values[0] != other->_values[0])) || 12477 (_valueSet[1] && (_values[1] != other->_values[1]))) { 12478 return NO; 12479 } 12480 return YES; 12481 } 12482 12483 - (NSUInteger)hash { 12484 return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0); 12485 } 12486 12487 - (NSString *)description { 12488 NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> {", [self class], self]; 12489 if (_valueSet[0]) { 12490 [result appendFormat:@"NO: %f", _values[0]]; 12491 } 12492 if (_valueSet[1]) { 12493 [result appendFormat:@"YES: %f", _values[1]]; 12494 } 12495 [result appendString:@" }"]; 12496 return result; 12497 } 12498 12499 - (NSUInteger)count { 12500 return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0); 12501 } 12502 12503 - (BOOL)valueForKey:(BOOL)key value:(float *)value { 12504 int idx = (key ? 1 : 0); 12505 if (_valueSet[idx]) { 12506 if (value) { 12507 *value = _values[idx]; 12508 } 12509 return YES; 12510 } 12511 return NO; 12512 } 12513 12514 - (void)setGPBGenericValue:(GPBGenericValue *)value 12515 forGPBGenericValueKey:(GPBGenericValue *)key { 12516 int idx = (key->valueBool ? 1 : 0); 12517 _values[idx] = value->valueFloat; 12518 _valueSet[idx] = YES; 12519 } 12520 12521 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 12522 if (_valueSet[0]) { 12523 block(@"false", [NSString stringWithFormat:@"%.*g", FLT_DIG, _values[0]]); 12524 } 12525 if (_valueSet[1]) { 12526 block(@"true", [NSString stringWithFormat:@"%.*g", FLT_DIG, _values[1]]); 12527 } 12528 } 12529 12530 - (void)enumerateKeysAndValuesUsingBlock: 12531 (void (^)(BOOL key, float value, BOOL *stop))block { 12532 BOOL stop = NO; 12533 if (_valueSet[0]) { 12534 block(NO, _values[0], &stop); 12535 } 12536 if (!stop && _valueSet[1]) { 12537 block(YES, _values[1], &stop); 12538 } 12539 } 12540 12541 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 12542 GPBDataType valueDataType = GPBGetFieldDataType(field); 12543 NSUInteger count = 0; 12544 size_t result = 0; 12545 for (int i = 0; i < 2; ++i) { 12546 if (_valueSet[i]) { 12547 ++count; 12548 size_t msgSize = ComputeDictBoolFieldSize((i == 1), kMapKeyFieldNumber, GPBDataTypeBool); 12549 msgSize += ComputeDictFloatFieldSize(_values[i], kMapValueFieldNumber, valueDataType); 12550 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 12551 } 12552 } 12553 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 12554 result += tagSize * count; 12555 return result; 12556 } 12557 12558 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 12559 asField:(GPBFieldDescriptor *)field { 12560 GPBDataType valueDataType = GPBGetFieldDataType(field); 12561 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 12562 for (int i = 0; i < 2; ++i) { 12563 if (_valueSet[i]) { 12564 // Write the tag. 12565 [outputStream writeInt32NoTag:tag]; 12566 // Write the size of the message. 12567 size_t msgSize = ComputeDictBoolFieldSize((i == 1), kMapKeyFieldNumber, GPBDataTypeBool); 12568 msgSize += ComputeDictFloatFieldSize(_values[i], kMapValueFieldNumber, valueDataType); 12569 [outputStream writeInt32NoTag:(int32_t)msgSize]; 12570 // Write the fields. 12571 WriteDictBoolField(outputStream, (i == 1), kMapKeyFieldNumber, GPBDataTypeBool); 12572 WriteDictFloatField(outputStream, _values[i], kMapValueFieldNumber, valueDataType); 12573 } 12574 } 12575 } 12576 12577 - (void)addEntriesFromDictionary:(GPBBoolFloatDictionary *)otherDictionary { 12578 if (otherDictionary) { 12579 for (int i = 0; i < 2; ++i) { 12580 if (otherDictionary->_valueSet[i]) { 12581 _valueSet[i] = YES; 12582 _values[i] = otherDictionary->_values[i]; 12583 } 12584 } 12585 if (_autocreator) { 12586 GPBAutocreatedDictionaryModified(_autocreator, self); 12587 } 12588 } 12589 } 12590 12591 - (void)setValue:(float)value forKey:(BOOL)key { 12592 int idx = (key ? 1 : 0); 12593 _values[idx] = value; 12594 _valueSet[idx] = YES; 12595 if (_autocreator) { 12596 GPBAutocreatedDictionaryModified(_autocreator, self); 12597 } 12598 } 12599 12600 - (void)removeValueForKey:(BOOL)aKey { 12601 _valueSet[aKey ? 1 : 0] = NO; 12602 } 12603 12604 - (void)removeAll { 12605 _valueSet[0] = NO; 12606 _valueSet[1] = NO; 12607 } 12608 12609 @end 12610 12611 //%PDDM-EXPAND DICTIONARY_BOOL_KEY_TO_POD_IMPL(Double, double) 12612 // This block of code is generated, do not edit it directly. 12613 12614 #pragma mark - Bool -> Double 12615 12616 @implementation GPBBoolDoubleDictionary { 12617 @package 12618 double _values[2]; 12619 BOOL _valueSet[2]; 12620 } 12621 12622 + (instancetype)dictionary { 12623 return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; 12624 } 12625 12626 + (instancetype)dictionaryWithValue:(double)value 12627 forKey:(BOOL)key { 12628 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 12629 // on to get the type correct. 12630 return [[(GPBBoolDoubleDictionary*)[self alloc] initWithValues:&value 12631 forKeys:&key 12632 count:1] autorelease]; 12633 } 12634 12635 + (instancetype)dictionaryWithValues:(const double [])values 12636 forKeys:(const BOOL [])keys 12637 count:(NSUInteger)count { 12638 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 12639 // on to get the type correct. 12640 return [[(GPBBoolDoubleDictionary*)[self alloc] initWithValues:values 12641 forKeys:keys 12642 count:count] autorelease]; 12643 } 12644 12645 + (instancetype)dictionaryWithDictionary:(GPBBoolDoubleDictionary *)dictionary { 12646 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 12647 // on to get the type correct. 12648 return [[(GPBBoolDoubleDictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 12649 } 12650 12651 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 12652 return [[[self alloc] initWithCapacity:numItems] autorelease]; 12653 } 12654 12655 - (instancetype)init { 12656 return [self initWithValues:NULL forKeys:NULL count:0]; 12657 } 12658 12659 - (instancetype)initWithValues:(const double [])values 12660 forKeys:(const BOOL [])keys 12661 count:(NSUInteger)count { 12662 self = [super init]; 12663 if (self) { 12664 for (NSUInteger i = 0; i < count; ++i) { 12665 int idx = keys[i] ? 1 : 0; 12666 _values[idx] = values[i]; 12667 _valueSet[idx] = YES; 12668 } 12669 } 12670 return self; 12671 } 12672 12673 - (instancetype)initWithDictionary:(GPBBoolDoubleDictionary *)dictionary { 12674 self = [self initWithValues:NULL forKeys:NULL count:0]; 12675 if (self) { 12676 if (dictionary) { 12677 for (int i = 0; i < 2; ++i) { 12678 if (dictionary->_valueSet[i]) { 12679 _values[i] = dictionary->_values[i]; 12680 _valueSet[i] = YES; 12681 } 12682 } 12683 } 12684 } 12685 return self; 12686 } 12687 12688 - (instancetype)initWithCapacity:(NSUInteger)numItems { 12689 #pragma unused(numItems) 12690 return [self initWithValues:NULL forKeys:NULL count:0]; 12691 } 12692 12693 #if !defined(NS_BLOCK_ASSERTIONS) 12694 - (void)dealloc { 12695 NSAssert(!_autocreator, 12696 @"%@: Autocreator must be cleared before release, autocreator: %@", 12697 [self class], _autocreator); 12698 [super dealloc]; 12699 } 12700 #endif // !defined(NS_BLOCK_ASSERTIONS) 12701 12702 - (instancetype)copyWithZone:(NSZone *)zone { 12703 return [[GPBBoolDoubleDictionary allocWithZone:zone] initWithDictionary:self]; 12704 } 12705 12706 - (BOOL)isEqual:(GPBBoolDoubleDictionary *)other { 12707 if (self == other) { 12708 return YES; 12709 } 12710 if (![other isKindOfClass:[GPBBoolDoubleDictionary class]]) { 12711 return NO; 12712 } 12713 if ((_valueSet[0] != other->_valueSet[0]) || 12714 (_valueSet[1] != other->_valueSet[1])) { 12715 return NO; 12716 } 12717 if ((_valueSet[0] && (_values[0] != other->_values[0])) || 12718 (_valueSet[1] && (_values[1] != other->_values[1]))) { 12719 return NO; 12720 } 12721 return YES; 12722 } 12723 12724 - (NSUInteger)hash { 12725 return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0); 12726 } 12727 12728 - (NSString *)description { 12729 NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> {", [self class], self]; 12730 if (_valueSet[0]) { 12731 [result appendFormat:@"NO: %lf", _values[0]]; 12732 } 12733 if (_valueSet[1]) { 12734 [result appendFormat:@"YES: %lf", _values[1]]; 12735 } 12736 [result appendString:@" }"]; 12737 return result; 12738 } 12739 12740 - (NSUInteger)count { 12741 return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0); 12742 } 12743 12744 - (BOOL)valueForKey:(BOOL)key value:(double *)value { 12745 int idx = (key ? 1 : 0); 12746 if (_valueSet[idx]) { 12747 if (value) { 12748 *value = _values[idx]; 12749 } 12750 return YES; 12751 } 12752 return NO; 12753 } 12754 12755 - (void)setGPBGenericValue:(GPBGenericValue *)value 12756 forGPBGenericValueKey:(GPBGenericValue *)key { 12757 int idx = (key->valueBool ? 1 : 0); 12758 _values[idx] = value->valueDouble; 12759 _valueSet[idx] = YES; 12760 } 12761 12762 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 12763 if (_valueSet[0]) { 12764 block(@"false", [NSString stringWithFormat:@"%.*lg", DBL_DIG, _values[0]]); 12765 } 12766 if (_valueSet[1]) { 12767 block(@"true", [NSString stringWithFormat:@"%.*lg", DBL_DIG, _values[1]]); 12768 } 12769 } 12770 12771 - (void)enumerateKeysAndValuesUsingBlock: 12772 (void (^)(BOOL key, double value, BOOL *stop))block { 12773 BOOL stop = NO; 12774 if (_valueSet[0]) { 12775 block(NO, _values[0], &stop); 12776 } 12777 if (!stop && _valueSet[1]) { 12778 block(YES, _values[1], &stop); 12779 } 12780 } 12781 12782 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 12783 GPBDataType valueDataType = GPBGetFieldDataType(field); 12784 NSUInteger count = 0; 12785 size_t result = 0; 12786 for (int i = 0; i < 2; ++i) { 12787 if (_valueSet[i]) { 12788 ++count; 12789 size_t msgSize = ComputeDictBoolFieldSize((i == 1), kMapKeyFieldNumber, GPBDataTypeBool); 12790 msgSize += ComputeDictDoubleFieldSize(_values[i], kMapValueFieldNumber, valueDataType); 12791 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 12792 } 12793 } 12794 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 12795 result += tagSize * count; 12796 return result; 12797 } 12798 12799 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 12800 asField:(GPBFieldDescriptor *)field { 12801 GPBDataType valueDataType = GPBGetFieldDataType(field); 12802 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 12803 for (int i = 0; i < 2; ++i) { 12804 if (_valueSet[i]) { 12805 // Write the tag. 12806 [outputStream writeInt32NoTag:tag]; 12807 // Write the size of the message. 12808 size_t msgSize = ComputeDictBoolFieldSize((i == 1), kMapKeyFieldNumber, GPBDataTypeBool); 12809 msgSize += ComputeDictDoubleFieldSize(_values[i], kMapValueFieldNumber, valueDataType); 12810 [outputStream writeInt32NoTag:(int32_t)msgSize]; 12811 // Write the fields. 12812 WriteDictBoolField(outputStream, (i == 1), kMapKeyFieldNumber, GPBDataTypeBool); 12813 WriteDictDoubleField(outputStream, _values[i], kMapValueFieldNumber, valueDataType); 12814 } 12815 } 12816 } 12817 12818 - (void)addEntriesFromDictionary:(GPBBoolDoubleDictionary *)otherDictionary { 12819 if (otherDictionary) { 12820 for (int i = 0; i < 2; ++i) { 12821 if (otherDictionary->_valueSet[i]) { 12822 _valueSet[i] = YES; 12823 _values[i] = otherDictionary->_values[i]; 12824 } 12825 } 12826 if (_autocreator) { 12827 GPBAutocreatedDictionaryModified(_autocreator, self); 12828 } 12829 } 12830 } 12831 12832 - (void)setValue:(double)value forKey:(BOOL)key { 12833 int idx = (key ? 1 : 0); 12834 _values[idx] = value; 12835 _valueSet[idx] = YES; 12836 if (_autocreator) { 12837 GPBAutocreatedDictionaryModified(_autocreator, self); 12838 } 12839 } 12840 12841 - (void)removeValueForKey:(BOOL)aKey { 12842 _valueSet[aKey ? 1 : 0] = NO; 12843 } 12844 12845 - (void)removeAll { 12846 _valueSet[0] = NO; 12847 _valueSet[1] = NO; 12848 } 12849 12850 @end 12851 12852 //%PDDM-EXPAND DICTIONARY_BOOL_KEY_TO_OBJECT_IMPL(Object, id) 12853 // This block of code is generated, do not edit it directly. 12854 12855 #pragma mark - Bool -> Object 12856 12857 @implementation GPBBoolObjectDictionary { 12858 @package 12859 id _values[2]; 12860 } 12861 12862 + (instancetype)dictionary { 12863 return [[[self alloc] initWithObjects:NULL forKeys:NULL count:0] autorelease]; 12864 } 12865 12866 + (instancetype)dictionaryWithObject:(id)object 12867 forKey:(BOOL)key { 12868 // Cast is needed so the compiler knows what class we are invoking initWithObjects:forKeys:count: 12869 // on to get the type correct. 12870 return [[(GPBBoolObjectDictionary*)[self alloc] initWithObjects:&object 12871 forKeys:&key 12872 count:1] autorelease]; 12873 } 12874 12875 + (instancetype)dictionaryWithObjects:(const id [])objects 12876 forKeys:(const BOOL [])keys 12877 count:(NSUInteger)count { 12878 // Cast is needed so the compiler knows what class we are invoking initWithObjects:forKeys:count: 12879 // on to get the type correct. 12880 return [[(GPBBoolObjectDictionary*)[self alloc] initWithObjects:objects 12881 forKeys:keys 12882 count:count] autorelease]; 12883 } 12884 12885 + (instancetype)dictionaryWithDictionary:(GPBBoolObjectDictionary *)dictionary { 12886 // Cast is needed so the compiler knows what class we are invoking initWithDictionary: 12887 // on to get the type correct. 12888 return [[(GPBBoolObjectDictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 12889 } 12890 12891 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems { 12892 return [[[self alloc] initWithCapacity:numItems] autorelease]; 12893 } 12894 12895 - (instancetype)init { 12896 return [self initWithObjects:NULL forKeys:NULL count:0]; 12897 } 12898 12899 - (instancetype)initWithObjects:(const id [])objects 12900 forKeys:(const BOOL [])keys 12901 count:(NSUInteger)count { 12902 self = [super init]; 12903 if (self) { 12904 for (NSUInteger i = 0; i < count; ++i) { 12905 if (!objects[i]) { 12906 [NSException raise:NSInvalidArgumentException 12907 format:@"Attempting to add nil object to a Dictionary"]; 12908 } 12909 int idx = keys[i] ? 1 : 0; 12910 [_values[idx] release]; 12911 _values[idx] = (id)[objects[i] retain]; 12912 } 12913 } 12914 return self; 12915 } 12916 12917 - (instancetype)initWithDictionary:(GPBBoolObjectDictionary *)dictionary { 12918 self = [self initWithObjects:NULL forKeys:NULL count:0]; 12919 if (self) { 12920 if (dictionary) { 12921 _values[0] = [dictionary->_values[0] retain]; 12922 _values[1] = [dictionary->_values[1] retain]; 12923 } 12924 } 12925 return self; 12926 } 12927 12928 - (instancetype)initWithCapacity:(NSUInteger)numItems { 12929 #pragma unused(numItems) 12930 return [self initWithObjects:NULL forKeys:NULL count:0]; 12931 } 12932 12933 - (void)dealloc { 12934 NSAssert(!_autocreator, 12935 @"%@: Autocreator must be cleared before release, autocreator: %@", 12936 [self class], _autocreator); 12937 [_values[0] release]; 12938 [_values[1] release]; 12939 [super dealloc]; 12940 } 12941 12942 - (instancetype)copyWithZone:(NSZone *)zone { 12943 return [[GPBBoolObjectDictionary allocWithZone:zone] initWithDictionary:self]; 12944 } 12945 12946 - (BOOL)isEqual:(GPBBoolObjectDictionary *)other { 12947 if (self == other) { 12948 return YES; 12949 } 12950 if (![other isKindOfClass:[GPBBoolObjectDictionary class]]) { 12951 return NO; 12952 } 12953 if (((_values[0] != nil) != (other->_values[0] != nil)) || 12954 ((_values[1] != nil) != (other->_values[1] != nil))) { 12955 return NO; 12956 } 12957 if (((_values[0] != nil) && (![_values[0] isEqual:other->_values[0]])) || 12958 ((_values[1] != nil) && (![_values[1] isEqual:other->_values[1]]))) { 12959 return NO; 12960 } 12961 return YES; 12962 } 12963 12964 - (NSUInteger)hash { 12965 return ((_values[0] != nil) ? 1 : 0) + ((_values[1] != nil) ? 1 : 0); 12966 } 12967 12968 - (NSString *)description { 12969 NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> {", [self class], self]; 12970 if ((_values[0] != nil)) { 12971 [result appendFormat:@"NO: %@", _values[0]]; 12972 } 12973 if ((_values[1] != nil)) { 12974 [result appendFormat:@"YES: %@", _values[1]]; 12975 } 12976 [result appendString:@" }"]; 12977 return result; 12978 } 12979 12980 - (NSUInteger)count { 12981 return ((_values[0] != nil) ? 1 : 0) + ((_values[1] != nil) ? 1 : 0); 12982 } 12983 12984 - (id)objectForKey:(BOOL)key { 12985 return _values[key ? 1 : 0]; 12986 } 12987 12988 - (void)setGPBGenericValue:(GPBGenericValue *)value 12989 forGPBGenericValueKey:(GPBGenericValue *)key { 12990 int idx = (key->valueBool ? 1 : 0); 12991 [_values[idx] release]; 12992 _values[idx] = [value->valueString retain]; 12993 } 12994 12995 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 12996 if (_values[0] != nil) { 12997 block(@"false", _values[0]); 12998 } 12999 if ((_values[1] != nil)) { 13000 block(@"true", _values[1]); 13001 } 13002 } 13003 13004 - (void)enumerateKeysAndObjectsUsingBlock: 13005 (void (^)(BOOL key, id object, BOOL *stop))block { 13006 BOOL stop = NO; 13007 if (_values[0] != nil) { 13008 block(NO, _values[0], &stop); 13009 } 13010 if (!stop && (_values[1] != nil)) { 13011 block(YES, _values[1], &stop); 13012 } 13013 } 13014 13015 - (BOOL)isInitialized { 13016 if (_values[0] && ![_values[0] isInitialized]) { 13017 return NO; 13018 } 13019 if (_values[1] && ![_values[1] isInitialized]) { 13020 return NO; 13021 } 13022 return YES; 13023 } 13024 13025 - (instancetype)deepCopyWithZone:(NSZone *)zone { 13026 GPBBoolObjectDictionary *newDict = 13027 [[GPBBoolObjectDictionary alloc] init]; 13028 for (int i = 0; i < 2; ++i) { 13029 if (_values[i] != nil) { 13030 newDict->_values[i] = [_values[i] copyWithZone:zone]; 13031 } 13032 } 13033 return newDict; 13034 } 13035 13036 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 13037 GPBDataType valueDataType = GPBGetFieldDataType(field); 13038 NSUInteger count = 0; 13039 size_t result = 0; 13040 for (int i = 0; i < 2; ++i) { 13041 if (_values[i] != nil) { 13042 ++count; 13043 size_t msgSize = ComputeDictBoolFieldSize((i == 1), kMapKeyFieldNumber, GPBDataTypeBool); 13044 msgSize += ComputeDictObjectFieldSize(_values[i], kMapValueFieldNumber, valueDataType); 13045 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 13046 } 13047 } 13048 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 13049 result += tagSize * count; 13050 return result; 13051 } 13052 13053 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 13054 asField:(GPBFieldDescriptor *)field { 13055 GPBDataType valueDataType = GPBGetFieldDataType(field); 13056 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 13057 for (int i = 0; i < 2; ++i) { 13058 if (_values[i] != nil) { 13059 // Write the tag. 13060 [outputStream writeInt32NoTag:tag]; 13061 // Write the size of the message. 13062 size_t msgSize = ComputeDictBoolFieldSize((i == 1), kMapKeyFieldNumber, GPBDataTypeBool); 13063 msgSize += ComputeDictObjectFieldSize(_values[i], kMapValueFieldNumber, valueDataType); 13064 [outputStream writeInt32NoTag:(int32_t)msgSize]; 13065 // Write the fields. 13066 WriteDictBoolField(outputStream, (i == 1), kMapKeyFieldNumber, GPBDataTypeBool); 13067 WriteDictObjectField(outputStream, _values[i], kMapValueFieldNumber, valueDataType); 13068 } 13069 } 13070 } 13071 13072 - (void)addEntriesFromDictionary:(GPBBoolObjectDictionary *)otherDictionary { 13073 if (otherDictionary) { 13074 for (int i = 0; i < 2; ++i) { 13075 if (otherDictionary->_values[i] != nil) { 13076 [_values[i] release]; 13077 _values[i] = [otherDictionary->_values[i] retain]; 13078 } 13079 } 13080 if (_autocreator) { 13081 GPBAutocreatedDictionaryModified(_autocreator, self); 13082 } 13083 } 13084 } 13085 13086 - (void)setObject:(id)object forKey:(BOOL)key { 13087 if (!object) { 13088 [NSException raise:NSInvalidArgumentException 13089 format:@"Attempting to add nil object to a Dictionary"]; 13090 } 13091 int idx = (key ? 1 : 0); 13092 [_values[idx] release]; 13093 _values[idx] = [object retain]; 13094 if (_autocreator) { 13095 GPBAutocreatedDictionaryModified(_autocreator, self); 13096 } 13097 } 13098 13099 - (void)removeObjectForKey:(BOOL)aKey { 13100 int idx = (aKey ? 1 : 0); 13101 [_values[idx] release]; 13102 _values[idx] = nil; 13103 } 13104 13105 - (void)removeAll { 13106 for (int i = 0; i < 2; ++i) { 13107 [_values[i] release]; 13108 _values[i] = nil; 13109 } 13110 } 13111 13112 @end 13113 13114 //%PDDM-EXPAND-END (8 expansions) 13115 13116 #pragma mark - Bool -> Enum 13117 13118 @implementation GPBBoolEnumDictionary { 13119 @package 13120 GPBEnumValidationFunc _validationFunc; 13121 int32_t _values[2]; 13122 BOOL _valueSet[2]; 13123 } 13124 13125 @synthesize validationFunc = _validationFunc; 13126 13127 + (instancetype)dictionary { 13128 return [[[self alloc] initWithValidationFunction:NULL 13129 rawValues:NULL 13130 forKeys:NULL 13131 count:0] autorelease]; 13132 } 13133 13134 + (instancetype)dictionaryWithValidationFunction:(GPBEnumValidationFunc)func { 13135 return [[[self alloc] initWithValidationFunction:func 13136 rawValues:NULL 13137 forKeys:NULL 13138 count:0] autorelease]; 13139 } 13140 13141 + (instancetype)dictionaryWithValidationFunction:(GPBEnumValidationFunc)func 13142 rawValue:(int32_t)rawValue 13143 forKey:(BOOL)key { 13144 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 13145 // on to get the type correct. 13146 return [[(GPBBoolEnumDictionary*)[self alloc] initWithValidationFunction:func 13147 rawValues:&rawValue 13148 forKeys:&key 13149 count:1] autorelease]; 13150 } 13151 13152 + (instancetype)dictionaryWithValidationFunction:(GPBEnumValidationFunc)func 13153 rawValues:(const int32_t [])values 13154 forKeys:(const BOOL [])keys 13155 count:(NSUInteger)count { 13156 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 13157 // on to get the type correct. 13158 return [[(GPBBoolEnumDictionary*)[self alloc] initWithValidationFunction:func 13159 rawValues:values 13160 forKeys:keys 13161 count:count] autorelease]; 13162 } 13163 13164 + (instancetype)dictionaryWithDictionary:(GPBBoolEnumDictionary *)dictionary { 13165 // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: 13166 // on to get the type correct. 13167 return [[(GPBBoolEnumDictionary*)[self alloc] initWithDictionary:dictionary] autorelease]; 13168 } 13169 13170 + (instancetype)dictionaryWithValidationFunction:(GPBEnumValidationFunc)func 13171 capacity:(NSUInteger)numItems { 13172 return [[[self alloc] initWithValidationFunction:func capacity:numItems] autorelease]; 13173 } 13174 13175 - (instancetype)init { 13176 return [self initWithValidationFunction:NULL rawValues:NULL forKeys:NULL count:0]; 13177 } 13178 13179 - (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func { 13180 return [self initWithValidationFunction:func rawValues:NULL forKeys:NULL count:0]; 13181 } 13182 13183 - (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func 13184 rawValues:(const int32_t [])rawValues 13185 forKeys:(const BOOL [])keys 13186 count:(NSUInteger)count { 13187 self = [super init]; 13188 if (self) { 13189 _validationFunc = (func != NULL ? func : DictDefault_IsValidValue); 13190 for (NSUInteger i = 0; i < count; ++i) { 13191 int idx = keys[i] ? 1 : 0; 13192 _values[idx] = rawValues[i]; 13193 _valueSet[idx] = YES; 13194 } 13195 } 13196 return self; 13197 } 13198 13199 - (instancetype)initWithDictionary:(GPBBoolEnumDictionary *)dictionary { 13200 self = [self initWithValidationFunction:dictionary.validationFunc 13201 rawValues:NULL 13202 forKeys:NULL 13203 count:0]; 13204 if (self) { 13205 if (dictionary) { 13206 for (int i = 0; i < 2; ++i) { 13207 if (dictionary->_valueSet[i]) { 13208 _values[i] = dictionary->_values[i]; 13209 _valueSet[i] = YES; 13210 } 13211 } 13212 } 13213 } 13214 return self; 13215 } 13216 13217 - (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func 13218 capacity:(NSUInteger)numItems { 13219 #pragma unused(numItems) 13220 return [self initWithValidationFunction:func rawValues:NULL forKeys:NULL count:0]; 13221 } 13222 13223 #if !defined(NS_BLOCK_ASSERTIONS) 13224 - (void)dealloc { 13225 NSAssert(!_autocreator, 13226 @"%@: Autocreator must be cleared before release, autocreator: %@", 13227 [self class], _autocreator); 13228 [super dealloc]; 13229 } 13230 #endif // !defined(NS_BLOCK_ASSERTIONS) 13231 13232 - (instancetype)copyWithZone:(NSZone *)zone { 13233 return [[GPBBoolEnumDictionary allocWithZone:zone] initWithDictionary:self]; 13234 } 13235 13236 - (BOOL)isEqual:(GPBBoolEnumDictionary *)other { 13237 if (self == other) { 13238 return YES; 13239 } 13240 if (![other isKindOfClass:[GPBBoolEnumDictionary class]]) { 13241 return NO; 13242 } 13243 if ((_valueSet[0] != other->_valueSet[0]) || 13244 (_valueSet[1] != other->_valueSet[1])) { 13245 return NO; 13246 } 13247 if ((_valueSet[0] && (_values[0] != other->_values[0])) || 13248 (_valueSet[1] && (_values[1] != other->_values[1]))) { 13249 return NO; 13250 } 13251 return YES; 13252 } 13253 13254 - (NSUInteger)hash { 13255 return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0); 13256 } 13257 13258 - (NSString *)description { 13259 NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> {", [self class], self]; 13260 if (_valueSet[0]) { 13261 [result appendFormat:@"NO: %d", _values[0]]; 13262 } 13263 if (_valueSet[1]) { 13264 [result appendFormat:@"YES: %d", _values[1]]; 13265 } 13266 [result appendString:@" }"]; 13267 return result; 13268 } 13269 13270 - (NSUInteger)count { 13271 return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0); 13272 } 13273 13274 - (BOOL)valueForKey:(BOOL)key value:(int32_t*)value { 13275 int idx = (key ? 1 : 0); 13276 if (_valueSet[idx]) { 13277 if (value) { 13278 int32_t result = _values[idx]; 13279 if (!_validationFunc(result)) { 13280 result = kGPBUnrecognizedEnumeratorValue; 13281 } 13282 *value = result; 13283 } 13284 return YES; 13285 } 13286 return NO; 13287 } 13288 13289 - (BOOL)valueForKey:(BOOL)key rawValue:(int32_t*)rawValue { 13290 int idx = (key ? 1 : 0); 13291 if (_valueSet[idx]) { 13292 if (rawValue) { 13293 *rawValue = _values[idx]; 13294 } 13295 return YES; 13296 } 13297 return NO; 13298 } 13299 13300 - (void)enumerateKeysAndValuesUsingBlock: 13301 (void (^)(BOOL key, int32_t value, BOOL *stop))block { 13302 BOOL stop = NO; 13303 if (_valueSet[0]) { 13304 block(NO, _values[0], &stop); 13305 } 13306 if (!stop && _valueSet[1]) { 13307 block(YES, _values[1], &stop); 13308 } 13309 } 13310 13311 - (void)enumerateKeysAndRawValuesUsingBlock: 13312 (void (^)(BOOL key, int32_t rawValue, BOOL *stop))block { 13313 BOOL stop = NO; 13314 GPBEnumValidationFunc func = _validationFunc; 13315 int32_t validatedValue; 13316 if (_valueSet[0]) { 13317 validatedValue = _values[0]; 13318 if (!func(validatedValue)) { 13319 validatedValue = kGPBUnrecognizedEnumeratorValue; 13320 } 13321 block(NO, validatedValue, &stop); 13322 } 13323 if (!stop && _valueSet[1]) { 13324 validatedValue = _values[1]; 13325 if (!func(validatedValue)) { 13326 validatedValue = kGPBUnrecognizedEnumeratorValue; 13327 } 13328 block(YES, validatedValue, &stop); 13329 } 13330 } 13331 13332 //%PDDM-EXPAND SERIAL_DATA_FOR_ENTRY_POD_Enum(Bool) 13333 // This block of code is generated, do not edit it directly. 13334 13335 - (NSData *)serializedDataForUnknownValue:(int32_t)value 13336 forKey:(GPBGenericValue *)key 13337 keyDataType:(GPBDataType)keyDataType { 13338 size_t msgSize = ComputeDictBoolFieldSize(key->valueBool, kMapKeyFieldNumber, keyDataType); 13339 msgSize += ComputeDictEnumFieldSize(value, kMapValueFieldNumber, GPBDataTypeEnum); 13340 NSMutableData *data = [NSMutableData dataWithLength:msgSize]; 13341 GPBCodedOutputStream *outputStream = [[GPBCodedOutputStream alloc] initWithData:data]; 13342 WriteDictBoolField(outputStream, key->valueBool, kMapKeyFieldNumber, keyDataType); 13343 WriteDictEnumField(outputStream, value, kMapValueFieldNumber, GPBDataTypeEnum); 13344 [outputStream release]; 13345 return data; 13346 } 13347 13348 //%PDDM-EXPAND-END SERIAL_DATA_FOR_ENTRY_POD_Enum(Bool) 13349 13350 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field { 13351 GPBDataType valueDataType = GPBGetFieldDataType(field); 13352 NSUInteger count = 0; 13353 size_t result = 0; 13354 for (int i = 0; i < 2; ++i) { 13355 if (_valueSet[i]) { 13356 ++count; 13357 size_t msgSize = ComputeDictBoolFieldSize((i == 1), kMapKeyFieldNumber, GPBDataTypeBool); 13358 msgSize += ComputeDictInt32FieldSize(_values[i], kMapValueFieldNumber, valueDataType); 13359 result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; 13360 } 13361 } 13362 size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); 13363 result += tagSize * count; 13364 return result; 13365 } 13366 13367 - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream 13368 asField:(GPBFieldDescriptor *)field { 13369 GPBDataType valueDataType = GPBGetFieldDataType(field); 13370 uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); 13371 for (int i = 0; i < 2; ++i) { 13372 if (_valueSet[i]) { 13373 // Write the tag. 13374 [outputStream writeInt32NoTag:tag]; 13375 // Write the size of the message. 13376 size_t msgSize = ComputeDictBoolFieldSize((i == 1), kMapKeyFieldNumber, GPBDataTypeBool); 13377 msgSize += ComputeDictInt32FieldSize(_values[i], kMapValueFieldNumber, valueDataType); 13378 [outputStream writeInt32NoTag:(int32_t)msgSize]; 13379 // Write the fields. 13380 WriteDictBoolField(outputStream, (i == 1), kMapKeyFieldNumber, GPBDataTypeBool); 13381 WriteDictInt32Field(outputStream, _values[i], kMapValueFieldNumber, valueDataType); 13382 } 13383 } 13384 } 13385 13386 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { 13387 if (_valueSet[0]) { 13388 block(@"false", @(_values[0])); 13389 } 13390 if (_valueSet[1]) { 13391 block(@"true", @(_values[1])); 13392 } 13393 } 13394 13395 - (void)setGPBGenericValue:(GPBGenericValue *)value 13396 forGPBGenericValueKey:(GPBGenericValue *)key { 13397 int idx = (key->valueBool ? 1 : 0); 13398 _values[idx] = value->valueInt32; 13399 _valueSet[idx] = YES; 13400 } 13401 13402 - (void)addRawEntriesFromDictionary:(GPBBoolEnumDictionary *)otherDictionary { 13403 if (otherDictionary) { 13404 for (int i = 0; i < 2; ++i) { 13405 if (otherDictionary->_valueSet[i]) { 13406 _valueSet[i] = YES; 13407 _values[i] = otherDictionary->_values[i]; 13408 } 13409 } 13410 if (_autocreator) { 13411 GPBAutocreatedDictionaryModified(_autocreator, self); 13412 } 13413 } 13414 } 13415 13416 - (void)setValue:(int32_t)value forKey:(BOOL)key { 13417 if (!_validationFunc(value)) { 13418 [NSException raise:NSInvalidArgumentException 13419 format:@"GPBBoolEnumDictionary: Attempt to set an unknown enum value (%d)", 13420 value]; 13421 } 13422 int idx = (key ? 1 : 0); 13423 _values[idx] = value; 13424 _valueSet[idx] = YES; 13425 if (_autocreator) { 13426 GPBAutocreatedDictionaryModified(_autocreator, self); 13427 } 13428 } 13429 13430 - (void)setRawValue:(int32_t)rawValue forKey:(BOOL)key { 13431 int idx = (key ? 1 : 0); 13432 _values[idx] = rawValue; 13433 _valueSet[idx] = YES; 13434 if (_autocreator) { 13435 GPBAutocreatedDictionaryModified(_autocreator, self); 13436 } 13437 } 13438 13439 - (void)removeValueForKey:(BOOL)aKey { 13440 _valueSet[aKey ? 1 : 0] = NO; 13441 } 13442 13443 - (void)removeAll { 13444 _valueSet[0] = NO; 13445 _valueSet[1] = NO; 13446 } 13447 13448 @end 13449 13450 #pragma mark - NSDictionary Subclass 13451 13452 @implementation GPBAutocreatedDictionary { 13453 NSMutableDictionary *_dictionary; 13454 } 13455 13456 - (void)dealloc { 13457 NSAssert(!_autocreator, 13458 @"%@: Autocreator must be cleared before release, autocreator: %@", 13459 [self class], _autocreator); 13460 [_dictionary release]; 13461 [super dealloc]; 13462 } 13463 13464 #pragma mark Required NSDictionary overrides 13465 13466 - (instancetype)initWithObjects:(const id [])objects 13467 forKeys:(const id<NSCopying> [])keys 13468 count:(NSUInteger)count { 13469 self = [super init]; 13470 if (self) { 13471 _dictionary = [[NSMutableDictionary alloc] initWithObjects:objects 13472 forKeys:keys 13473 count:count]; 13474 } 13475 return self; 13476 } 13477 13478 - (NSUInteger)count { 13479 return [_dictionary count]; 13480 } 13481 13482 - (id)objectForKey:(id)aKey { 13483 return [_dictionary objectForKey:aKey]; 13484 } 13485 13486 - (NSEnumerator *)keyEnumerator { 13487 if (_dictionary == nil) { 13488 _dictionary = [[NSMutableDictionary alloc] init]; 13489 } 13490 return [_dictionary keyEnumerator]; 13491 } 13492 13493 #pragma mark Required NSMutableDictionary overrides 13494 13495 // Only need to call GPBAutocreatedDictionaryModified() when adding things 13496 // since we only autocreate empty dictionaries. 13497 13498 - (void)setObject:(id)anObject forKey:(id<NSCopying>)aKey { 13499 if (_dictionary == nil) { 13500 _dictionary = [[NSMutableDictionary alloc] init]; 13501 } 13502 [_dictionary setObject:anObject forKey:aKey]; 13503 if (_autocreator) { 13504 GPBAutocreatedDictionaryModified(_autocreator, self); 13505 } 13506 } 13507 13508 - (void)removeObjectForKey:(id)aKey { 13509 [_dictionary removeObjectForKey:aKey]; 13510 } 13511 13512 #pragma mark Extra things hooked 13513 13514 - (id)copyWithZone:(NSZone *)zone { 13515 if (_dictionary == nil) { 13516 _dictionary = [[NSMutableDictionary alloc] init]; 13517 } 13518 return [_dictionary copyWithZone:zone]; 13519 } 13520 13521 - (id)mutableCopyWithZone:(NSZone *)zone { 13522 if (_dictionary == nil) { 13523 _dictionary = [[NSMutableDictionary alloc] init]; 13524 } 13525 return [_dictionary mutableCopyWithZone:zone]; 13526 } 13527 13528 - (id)objectForKeyedSubscript:(id)key { 13529 return [_dictionary objectForKeyedSubscript:key]; 13530 } 13531 13532 - (void)setObject:(id)obj forKeyedSubscript:(id<NSCopying>)key { 13533 if (_dictionary == nil) { 13534 _dictionary = [[NSMutableDictionary alloc] init]; 13535 } 13536 [_dictionary setObject:obj forKeyedSubscript:key]; 13537 if (_autocreator) { 13538 GPBAutocreatedDictionaryModified(_autocreator, self); 13539 } 13540 } 13541 13542 - (void)enumerateKeysAndObjectsUsingBlock:(void (^)(id key, 13543 id obj, 13544 BOOL *stop))block { 13545 [_dictionary enumerateKeysAndObjectsUsingBlock:block]; 13546 } 13547 13548 - (void)enumerateKeysAndObjectsWithOptions:(NSEnumerationOptions)opts 13549 usingBlock:(void (^)(id key, 13550 id obj, 13551 BOOL *stop))block { 13552 [_dictionary enumerateKeysAndObjectsWithOptions:opts usingBlock:block]; 13553 } 13554 13555 @end 13556
