From 30650d81d9baa446dbc8deb784ba53794cafda5b Mon Sep 17 00:00:00 2001 From: Thomas Van Lenten Date: Fri, 1 May 2015 08:57:16 -0400 Subject: Alpha 1 drop of Google's Objective C plugin and runtime support for protobufs. --- objectivec/GPBMessage.m | 4735 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 4735 insertions(+) create mode 100644 objectivec/GPBMessage.m (limited to 'objectivec/GPBMessage.m') diff --git a/objectivec/GPBMessage.m b/objectivec/GPBMessage.m new file mode 100644 index 00000000..63ffc3bc --- /dev/null +++ b/objectivec/GPBMessage.m @@ -0,0 +1,4735 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#import "GPBMessage_PackagePrivate.h" + +#import +#import + +#import "GPBArray_PackagePrivate.h" +#import "GPBCodedInputStream_PackagePrivate.h" +#import "GPBCodedOutputStream.h" +#import "GPBDescriptor_PackagePrivate.h" +#import "GPBDictionary_PackagePrivate.h" +#import "GPBExtensionField_PackagePrivate.h" +#import "GPBExtensionRegistry_PackagePrivate.h" +#import "GPBUnknownFieldSet_PackagePrivate.h" +#import "GPBUtilities_PackagePrivate.h" + +#ifdef DEBUG +NSString *const GPBExceptionMessageKey = + GPBNSStringifySymbol(GPBExceptionMessage); +#endif // DEBUG + +// +// PLEASE REMEMBER: +// +// This is the base class for *all* messages generated, so any selector defined, +// *public* or *private* could end up colliding with a proto message field. So +// avoid using selectors that could match a property, use C functions to hide +// them, etc. +// + +@interface GPBMessage () { + @package + GPBUnknownFieldSet *unknownFields_; + NSMutableDictionary *extensionMap_; + NSMutableDictionary *autocreatedExtensionMap_; + + // If the object was autocreated, we remember the creator so that if we get + // mutated, we can inform the creator to make our field visible. + GPBMessage *autocreator_; + GPBFieldDescriptor *autocreatorField_; + GPBExtensionField *autocreatorExtension_; +} +@end + +static id CreateArrayForField(GPBFieldDescriptor *field, + GPBMessage *autocreator) + __attribute__((ns_returns_retained)); +static id GetOrCreateArrayIvarWithField(GPBMessage *self, + GPBFieldDescriptor *field, + GPBFileSyntax syntax); +static id GetArrayIvarWithField(GPBMessage *self, GPBFieldDescriptor *field); +static id GetOrCreateMapIvarWithField(GPBMessage *self, + GPBFieldDescriptor *field, + GPBFileSyntax syntax); +static NSMutableDictionary *CloneExtensionMap(NSDictionary *extensionMap, + NSZone *zone) + __attribute__((ns_returns_retained)); + +static void CheckExtension(GPBMessage *self, GPBExtensionField *extension) { + if ([[self class] descriptor] != [extension containingType]) { + [NSException + raise:NSInvalidArgumentException + format:@"Extension %@ used on wrong class (%@ instead of %@)", + extension.descriptor.singletonName, + [[self class] descriptor].name, [extension containingType].name]; + } +} + +static NSMutableDictionary *CloneExtensionMap(NSDictionary *extensionMap, + NSZone *zone) { + if (extensionMap.count == 0) { + return nil; + } + NSMutableDictionary *result = [[NSMutableDictionary allocWithZone:zone] + initWithCapacity:extensionMap.count]; + + for (GPBExtensionField *field in extensionMap) { + id value = [extensionMap objectForKey:field]; + GPBExtensionDescriptor *fieldDescriptor = field.descriptor; + BOOL isMessageExtension = GPBExtensionIsMessage(fieldDescriptor); + + if ([field isRepeated]) { + if (isMessageExtension) { + NSMutableArray *list = + [[NSMutableArray alloc] initWithCapacity:[value count]]; + for (GPBMessage *listValue in value) { + GPBMessage *copiedValue = [listValue copyWithZone:zone]; + [list addObject:copiedValue]; + [copiedValue release]; + } + [result setObject:list forKey:field]; + [list release]; + } else { + NSMutableArray *copiedValue = [value mutableCopyWithZone:zone]; + [result setObject:copiedValue forKey:field]; + [copiedValue release]; + } + } else { + if (isMessageExtension) { + GPBMessage *copiedValue = [value copyWithZone:zone]; + [result setObject:copiedValue forKey:field]; + [copiedValue release]; + } else { + [result setObject:value forKey:field]; + } + } + } + + return result; +} + +static id CreateArrayForField(GPBFieldDescriptor *field, + GPBMessage *autocreator) { + id result; + GPBType fieldDataType = GPBGetFieldType(field); + switch (fieldDataType) { + case GPBTypeBool: + result = [[GPBBoolArray alloc] init]; + break; + case GPBTypeFixed32: + case GPBTypeUInt32: + result = [[GPBUInt32Array alloc] init]; + break; + case GPBTypeInt32: + case GPBTypeSFixed32: + case GPBTypeSInt32: + result = [[GPBInt32Array alloc] init]; + break; + case GPBTypeFixed64: + case GPBTypeUInt64: + result = [[GPBUInt64Array alloc] init]; + break; + case GPBTypeInt64: + case GPBTypeSFixed64: + case GPBTypeSInt64: + result = [[GPBInt64Array alloc] init]; + break; + case GPBTypeFloat: + result = [[GPBFloatArray alloc] init]; + break; + case GPBTypeDouble: + result = [[GPBDoubleArray alloc] init]; + break; + + case GPBTypeEnum: + result = [[GPBEnumArray alloc] + initWithValidationFunction:field.enumDescriptor.enumVerifier]; + break; + + case GPBTypeData: + case GPBTypeGroup: + case GPBTypeMessage: + case GPBTypeString: + if (autocreator) { + result = [[GPBAutocreatedArray alloc] init]; + } else { + result = [[NSMutableArray alloc] init]; + } + break; + } + + if (autocreator) { + if (GPBTypeIsObject(fieldDataType)) { + GPBAutocreatedArray *autoArray = result; + autoArray->_autocreator = autocreator; + } else { + GPBInt32Array *gpbArray = result; + gpbArray->_autocreator = autocreator; + } + } + + return result; +} + + +#if !defined(__clang_analyzer__) +// These functions are blocked from the analyzer because the analyzer sees the +// GPBSetRetainedObjectIvarWithFieldInternal() call as consuming the array/map, +// so use of the array/map after the call returns is flagged as a use after +// free. +// But GPBSetRetainedObjectIvarWithFieldInternal() is "consuming" the retain +// count be holding onto the object (it is transfering it), the object is +// still valid after returning from the call. The other way to avoid this +// would be to add a -retain/-autorelease, but that would force every +// repeated/map field parsed into the autorelease pool which is both a memory +// and performance hit. + +static id GetOrCreateArrayIvarWithField(GPBMessage *self, + GPBFieldDescriptor *field, + GPBFileSyntax syntax) { + id array = GPBGetObjectIvarWithFieldNoAutocreate(self, field); + if (!array) { + // No lock needed, this is called from places expecting to mutate + // so no threading protection is needed. + array = CreateArrayForField(field, nil); + GPBSetRetainedObjectIvarWithFieldInternal(self, field, array, syntax); + } + return array; +} + +// This is like GPBGetObjectIvarWithField(), but for arrays, it should +// only be used to wire the method into the class. +static id GetArrayIvarWithField(GPBMessage *self, GPBFieldDescriptor *field) { + id array = GPBGetObjectIvarWithFieldNoAutocreate(self, field); + if (!array) { + // Check again after getting the lock. + OSSpinLockLock(&self->readOnlyMutex_); + array = GPBGetObjectIvarWithFieldNoAutocreate(self, field); + if (!array) { + array = CreateArrayForField(field, self); + GPBSetAutocreatedRetainedObjectIvarWithField(self, field, array); + } + OSSpinLockUnlock(&self->readOnlyMutex_); + } + return array; +} + +static id GetOrCreateMapIvarWithField(GPBMessage *self, + GPBFieldDescriptor *field, + GPBFileSyntax syntax) { + id dict = GPBGetObjectIvarWithFieldNoAutocreate(self, field); + if (!dict) { + GPBType keyType = field.mapKeyType; + GPBType valueType = GPBGetFieldType(field); + switch (keyType) { + case GPBTypeBool: + switch (valueType) { + case GPBTypeBool: + dict = [[GPBBoolBoolDictionary alloc] init]; + break; + case GPBTypeFixed32: + case GPBTypeUInt32: + dict = [[GPBBoolUInt32Dictionary alloc] init]; + break; + case GPBTypeInt32: + case GPBTypeSFixed32: + case GPBTypeSInt32: + dict = [[GPBBoolInt32Dictionary alloc] init]; + break; + case GPBTypeFixed64: + case GPBTypeUInt64: + dict = [[GPBBoolUInt64Dictionary alloc] init]; + break; + case GPBTypeInt64: + case GPBTypeSFixed64: + case GPBTypeSInt64: + dict = [[GPBBoolInt64Dictionary alloc] init]; + break; + case GPBTypeFloat: + dict = [[GPBBoolFloatDictionary alloc] init]; + break; + case GPBTypeDouble: + dict = [[GPBBoolDoubleDictionary alloc] init]; + break; + case GPBTypeEnum: + dict = [[GPBBoolEnumDictionary alloc] + initWithValidationFunction:field.enumDescriptor.enumVerifier]; + break; + case GPBTypeData: + case GPBTypeMessage: + case GPBTypeString: + dict = [[GPBBoolObjectDictionary alloc] init]; + break; + case GPBTypeGroup: + NSCAssert(NO, @"shouldn't happen"); + return nil; + } + break; + case GPBTypeFixed32: + case GPBTypeUInt32: + switch (valueType) { + case GPBTypeBool: + dict = [[GPBUInt32BoolDictionary alloc] init]; + break; + case GPBTypeFixed32: + case GPBTypeUInt32: + dict = [[GPBUInt32UInt32Dictionary alloc] init]; + break; + case GPBTypeInt32: + case GPBTypeSFixed32: + case GPBTypeSInt32: + dict = [[GPBUInt32Int32Dictionary alloc] init]; + break; + case GPBTypeFixed64: + case GPBTypeUInt64: + dict = [[GPBUInt32UInt64Dictionary alloc] init]; + break; + case GPBTypeInt64: + case GPBTypeSFixed64: + case GPBTypeSInt64: + dict = [[GPBUInt32Int64Dictionary alloc] init]; + break; + case GPBTypeFloat: + dict = [[GPBUInt32FloatDictionary alloc] init]; + break; + case GPBTypeDouble: + dict = [[GPBUInt32DoubleDictionary alloc] init]; + break; + case GPBTypeEnum: + dict = [[GPBUInt32EnumDictionary alloc] + initWithValidationFunction:field.enumDescriptor.enumVerifier]; + break; + case GPBTypeData: + case GPBTypeMessage: + case GPBTypeString: + dict = [[GPBUInt32ObjectDictionary alloc] init]; + break; + case GPBTypeGroup: + NSCAssert(NO, @"shouldn't happen"); + return nil; + } + break; + case GPBTypeInt32: + case GPBTypeSFixed32: + case GPBTypeSInt32: + switch (valueType) { + case GPBTypeBool: + dict = [[GPBInt32BoolDictionary alloc] init]; + break; + case GPBTypeFixed32: + case GPBTypeUInt32: + dict = [[GPBInt32UInt32Dictionary alloc] init]; + break; + case GPBTypeInt32: + case GPBTypeSFixed32: + case GPBTypeSInt32: + dict = [[GPBInt32Int32Dictionary alloc] init]; + break; + case GPBTypeFixed64: + case GPBTypeUInt64: + dict = [[GPBInt32UInt64Dictionary alloc] init]; + break; + case GPBTypeInt64: + case GPBTypeSFixed64: + case GPBTypeSInt64: + dict = [[GPBInt32Int64Dictionary alloc] init]; + break; + case GPBTypeFloat: + dict = [[GPBInt32FloatDictionary alloc] init]; + break; + case GPBTypeDouble: + dict = [[GPBInt32DoubleDictionary alloc] init]; + break; + case GPBTypeEnum: + dict = [[GPBInt32EnumDictionary alloc] + initWithValidationFunction:field.enumDescriptor.enumVerifier]; + break; + case GPBTypeData: + case GPBTypeMessage: + case GPBTypeString: + dict = [[GPBInt32ObjectDictionary alloc] init]; + break; + case GPBTypeGroup: + NSCAssert(NO, @"shouldn't happen"); + return nil; + } + break; + case GPBTypeFixed64: + case GPBTypeUInt64: + switch (valueType) { + case GPBTypeBool: + dict = [[GPBUInt64BoolDictionary alloc] init]; + break; + case GPBTypeFixed32: + case GPBTypeUInt32: + dict = [[GPBUInt64UInt32Dictionary alloc] init]; + break; + case GPBTypeInt32: + case GPBTypeSFixed32: + case GPBTypeSInt32: + dict = [[GPBUInt64Int32Dictionary alloc] init]; + break; + case GPBTypeFixed64: + case GPBTypeUInt64: + dict = [[GPBUInt64UInt64Dictionary alloc] init]; + break; + case GPBTypeInt64: + case GPBTypeSFixed64: + case GPBTypeSInt64: + dict = [[GPBUInt64Int64Dictionary alloc] init]; + break; + case GPBTypeFloat: + dict = [[GPBUInt64FloatDictionary alloc] init]; + break; + case GPBTypeDouble: + dict = [[GPBUInt64DoubleDictionary alloc] init]; + break; + case GPBTypeEnum: + dict = [[GPBUInt64EnumDictionary alloc] + initWithValidationFunction:field.enumDescriptor.enumVerifier]; + break; + case GPBTypeData: + case GPBTypeMessage: + case GPBTypeString: + dict = [[GPBUInt64ObjectDictionary alloc] init]; + break; + case GPBTypeGroup: + NSCAssert(NO, @"shouldn't happen"); + return nil; + } + break; + case GPBTypeInt64: + case GPBTypeSFixed64: + case GPBTypeSInt64: + switch (valueType) { + case GPBTypeBool: + dict = [[GPBInt64BoolDictionary alloc] init]; + break; + case GPBTypeFixed32: + case GPBTypeUInt32: + dict = [[GPBInt64UInt32Dictionary alloc] init]; + break; + case GPBTypeInt32: + case GPBTypeSFixed32: + case GPBTypeSInt32: + dict = [[GPBInt64Int32Dictionary alloc] init]; + break; + case GPBTypeFixed64: + case GPBTypeUInt64: + dict = [[GPBInt64UInt64Dictionary alloc] init]; + break; + case GPBTypeInt64: + case GPBTypeSFixed64: + case GPBTypeSInt64: + dict = [[GPBInt64Int64Dictionary alloc] init]; + break; + case GPBTypeFloat: + dict = [[GPBInt64FloatDictionary alloc] init]; + break; + case GPBTypeDouble: + dict = [[GPBInt64DoubleDictionary alloc] init]; + break; + case GPBTypeEnum: + dict = [[GPBInt64EnumDictionary alloc] + initWithValidationFunction:field.enumDescriptor.enumVerifier]; + break; + case GPBTypeData: + case GPBTypeMessage: + case GPBTypeString: + dict = [[GPBInt64ObjectDictionary alloc] init]; + break; + case GPBTypeGroup: + NSCAssert(NO, @"shouldn't happen"); + return nil; + } + break; + case GPBTypeString: + switch (valueType) { + case GPBTypeBool: + dict = [[GPBStringBoolDictionary alloc] init]; + break; + case GPBTypeFixed32: + case GPBTypeUInt32: + dict = [[GPBStringUInt32Dictionary alloc] init]; + break; + case GPBTypeInt32: + case GPBTypeSFixed32: + case GPBTypeSInt32: + dict = [[GPBStringInt32Dictionary alloc] init]; + break; + case GPBTypeFixed64: + case GPBTypeUInt64: + dict = [[GPBStringUInt64Dictionary alloc] init]; + break; + case GPBTypeInt64: + case GPBTypeSFixed64: + case GPBTypeSInt64: + dict = [[GPBStringInt64Dictionary alloc] init]; + break; + case GPBTypeFloat: + dict = [[GPBStringFloatDictionary alloc] init]; + break; + case GPBTypeDouble: + dict = [[GPBStringDoubleDictionary alloc] init]; + break; + case GPBTypeEnum: + dict = [[GPBStringEnumDictionary alloc] + initWithValidationFunction:field.enumDescriptor.enumVerifier]; + break; + case GPBTypeData: + case GPBTypeMessage: + case GPBTypeString: + dict = [[NSMutableDictionary alloc] init]; + break; + case GPBTypeGroup: + NSCAssert(NO, @"shouldn't happen"); + return nil; + } + break; + + case GPBTypeFloat: + case GPBTypeDouble: + case GPBTypeEnum: + case GPBTypeData: + case GPBTypeGroup: + case GPBTypeMessage: + NSCAssert(NO, @"shouldn't happen"); + return nil; + } + + GPBSetRetainedObjectIvarWithFieldInternal(self, field, dict, syntax); + } + return dict; +} + +#endif // !defined(__clang_analyzer__) + +GPBMessage *GPBCreateMessageWithAutocreator(Class msgClass, + GPBMessage *autocreator, + GPBFieldDescriptor *field) { + GPBMessage *message = [[msgClass alloc] init]; + message->autocreator_ = autocreator; + message->autocreatorField_ = [field retain]; + return message; +} + +static GPBMessage *CreateMessageWithAutocreatorForExtension( + Class msgClass, GPBMessage *autocreator, GPBExtensionField *extension) + __attribute__((ns_returns_retained)); + +static GPBMessage *CreateMessageWithAutocreatorForExtension( + Class msgClass, GPBMessage *autocreator, GPBExtensionField *extension) { + GPBMessage *message = [[msgClass alloc] init]; + message->autocreator_ = autocreator; + message->autocreatorExtension_ = [extension retain]; + return message; +} + +BOOL GPBWasMessageAutocreatedBy(GPBMessage *message, GPBMessage *parent) { + return (message->autocreator_ == parent); +} + +void GPBBecomeVisibleToAutocreator(GPBMessage *self) { + // Message objects that are implicitly created by accessing a message field + // are initially not visible via the hasX selector. This method makes them + // visible. + if (self->autocreator_) { + // This will recursively make all parent messages visible until it reaches a + // super-creator that's visible. + if (self->autocreatorField_) { + GPBFileSyntax syntax = [self->autocreator_ descriptor].file.syntax; + GPBSetObjectIvarWithFieldInternal(self->autocreator_, + self->autocreatorField_, self, syntax); + } else { + [self->autocreator_ setExtension:self->autocreatorExtension_ value:self]; + } + } +} + +void GPBAutocreatedArrayModified(GPBMessage *self, id array) { + // When one of our autocreated arrays adds elements, make it visible. + GPBDescriptor *descriptor = [[self class] descriptor]; + for (GPBFieldDescriptor *field in descriptor->fields_) { + if (field.fieldType == GPBFieldTypeRepeated) { + id curArray = GPBGetObjectIvarWithFieldNoAutocreate(self, field); + if (curArray == array) { + if (GPBFieldTypeIsObject(field)) { + GPBAutocreatedArray *autoArray = array; + autoArray->_autocreator = nil; + } else { + GPBInt32Array *gpbArray = array; + gpbArray->_autocreator = nil; + } + GPBBecomeVisibleToAutocreator(self); + return; + } + } + } + NSCAssert(NO, @"Unknown array."); +} + +void GPBClearMessageAutocreator(GPBMessage *self) { + if ((self == nil) || !self->autocreator_) { + return; + } + +#if DEBUG && !defined(NS_BLOCK_ASSERTIONS) + // Either the autocreator must have its "has" flag set to YES, or it must be + // NO and not equal to ourselves. + BOOL autocreatorHas = + (self->autocreatorField_ + ? GPBGetHasIvarField(self->autocreator_, self->autocreatorField_) + : [self->autocreator_ hasExtension:self->autocreatorExtension_]); + GPBMessage *autocreatorFieldValue = + (self->autocreatorField_ + ? GPBGetObjectIvarWithFieldNoAutocreate(self->autocreator_, + self->autocreatorField_) + : [self->autocreator_->autocreatedExtensionMap_ + objectForKey:self->autocreatorExtension_]); + NSCAssert(autocreatorHas || autocreatorFieldValue != self, + @"Cannot clear autocreator because it still refers to self."); + +#endif // DEBUG && !defined(NS_BLOCK_ASSERTIONS) + + self->autocreator_ = nil; + [self->autocreatorField_ release]; + self->autocreatorField_ = nil; + [self->autocreatorExtension_ release]; + self->autocreatorExtension_ = nil; +} + +static GPBUnknownFieldSet *GetOrMakeUnknownFields(GPBMessage *self) { + if (!self->unknownFields_) { + self->unknownFields_ = [[GPBUnknownFieldSet alloc] init]; + GPBBecomeVisibleToAutocreator(self); + } + return self->unknownFields_; +} + +#ifdef DEBUG +static void DebugRaiseExceptionIfNotInitialized(GPBMessage *message) { + if (!message.initialized) { + NSString *reason = + [NSString stringWithFormat:@"Uninitialized Message %@", message]; + NSDictionary *userInfo = + message ? @{GPBExceptionMessageKey : message} : nil; + NSException *exception = + [NSException exceptionWithName:NSInternalInconsistencyException + reason:reason + userInfo:userInfo]; + [exception raise]; + } +} +#else +GPB_INLINE void DebugRaiseExceptionIfNotInitialized(GPBMessage *message) { +#pragma unused(message) +} +#endif // DEBUG + +@implementation GPBMessage + ++ (void)initialize { + Class pbMessageClass = [GPBMessage class]; + if ([self class] == pbMessageClass) { + // This is here to start up the "base" class descriptor. + [self descriptor]; + } else if ([self superclass] == pbMessageClass) { + // This is here to start up all the "message" subclasses. Just needs to be + // done for the messages, not any of the subclasses. + // This must be done in initialize to enforce thread safety of start up of + // the protocol buffer library. All of the extension registries must be + // created in either "+load" or "+initialize". + [self descriptor]; + [self extensionRegistry]; + } +} + ++ (instancetype)allocWithZone:(NSZone *)zone { + // Override alloc to allocate our classes with the additional storage + // required for the instance variables. + GPBDescriptor *descriptor = [self descriptor]; + return NSAllocateObject(self, descriptor->storageSize_, zone); +} + ++ (instancetype)alloc { + return [self allocWithZone:nil]; +} + ++ (GPBDescriptor *)descriptor { + // This is thread safe because it is called from +initialize. + static GPBDescriptor *descriptor = NULL; + static GPBFileDescriptor *fileDescriptor = NULL; + if (!descriptor) { + // Use a dummy file that marks it as proto2 syntax so when used generically + // it supports unknowns/etc. + fileDescriptor = + [[GPBFileDescriptor alloc] initWithPackage:@"internal" + syntax:GPBFileSyntaxProto2]; + + descriptor = [GPBDescriptor allocDescriptorForClass:[GPBMessage class] + rootClass:Nil + file:fileDescriptor + fields:NULL + fieldCount:0 + oneofs:NULL + oneofCount:0 + enums:NULL + enumCount:0 + ranges:NULL + rangeCount:0 + storageSize:0 + wireFormat:NO]; + } + return descriptor; +} + ++ (instancetype)message { + return [[[self alloc] init] autorelease]; +} + +- (instancetype)init { + if ((self = [super init])) { + messageStorage_ = (GPBMessage_StoragePtr)( + ((uint8_t *)self) + class_getInstanceSize([self class])); + + readOnlyMutex_ = OS_SPINLOCK_INIT; + } + + return self; +} + +- (instancetype)initWithData:(NSData *)data { + return [self initWithData:data extensionRegistry:nil]; +} + +- (instancetype)initWithData:(NSData *)data + extensionRegistry:(GPBExtensionRegistry *)extensionRegistry { + if ((self = [self init])) { + [self mergeFromData:data extensionRegistry:extensionRegistry]; + DebugRaiseExceptionIfNotInitialized(self); + } + return self; +} + +- (instancetype)initWithCodedInputStream:(GPBCodedInputStream *)input + extensionRegistry: + (GPBExtensionRegistry *)extensionRegistry { + if ((self = [self init])) { + [self mergeFromCodedInputStream:input extensionRegistry:extensionRegistry]; + DebugRaiseExceptionIfNotInitialized(self); + } + return self; +} + +- (void)dealloc { + [self internalClear:NO]; + NSCAssert(!autocreator_, @"Autocreator was not cleared before dealloc."); + [super dealloc]; +} + +- (void)copyFieldsInto:(GPBMessage *)message + zone:(NSZone *)zone + descriptor:(GPBDescriptor *)descriptor { + // Copy all the storage... + memcpy(message->messageStorage_, messageStorage_, descriptor->storageSize_); + + GPBFileSyntax syntax = descriptor.file.syntax; + + // Loop over the fields doing fixup... + for (GPBFieldDescriptor *field in descriptor->fields_) { + if (GPBFieldIsMapOrArray(field)) { + id value = GPBGetObjectIvarWithFieldNoAutocreate(self, field); + if (value) { + // We need to copy the array/map, but the catch is for message fields, + // we also need to ensure all the messages as those need copying also. + id newValue; + if (GPBFieldTypeIsMessage(field)) { + if (field.fieldType == GPBFieldTypeRepeated) { + NSArray *existingArray = (NSArray *)value; + NSMutableArray *newArray = + [[NSMutableArray alloc] initWithCapacity:existingArray.count]; + newValue = newArray; + for (GPBMessage *msg in existingArray) { + GPBMessage *copiedMsg = [msg copyWithZone:zone]; + [newArray addObject:copiedMsg]; + [copiedMsg release]; + } + } else { + if (field.mapKeyType == GPBTypeString) { + // Map is an NSDictionary. + NSDictionary *existingDict = value; + NSMutableDictionary *newDict = [[NSMutableDictionary alloc] + initWithCapacity:existingDict.count]; + newValue = newDict; + [existingDict enumerateKeysAndObjectsUsingBlock:^(NSString *key, + GPBMessage *msg, + BOOL *stop) { +#pragma unused(stop) + GPBMessage *copiedMsg = [msg copyWithZone:zone]; + [newDict setObject:copiedMsg forKey:key]; + [copiedMsg release]; + }]; + } else { + // Is one of the GPB*ObjectDictionary classes. Type doesn't + // matter, just need one to invoke the selector. + GPBInt32ObjectDictionary *existingDict = value; + newValue = [existingDict deepCopyWithZone:zone]; + } + } + } else { + // Not messages (but is a map/array)... + if (field.fieldType == GPBFieldTypeRepeated) { + if (GPBFieldTypeIsObject(field)) { + // NSArray + newValue = [value mutableCopyWithZone:zone]; + } else { + // GPB*Array + newValue = [value copyWithZone:zone]; + } + } else { + if (field.mapKeyType == GPBTypeString) { + // NSDictionary + newValue = [value mutableCopyWithZone:zone]; + } else { + // Is one of the GPB*Dictionary classes. Type doesn't matter, + // just need one to invoke the selector. + GPBInt32Int32Dictionary *existingDict = value; + newValue = [existingDict copyWithZone:zone]; + } + } + } + // We retain here because the memcpy picked up the pointer value and + // the next call to SetRetainedObject... will release the current value. + [value retain]; + GPBSetRetainedObjectIvarWithFieldInternal(message, field, newValue, + syntax); + } + } else if (GPBFieldTypeIsMessage(field)) { + // For object types, if we have a value, copy it. If we don't, + // zero it to remove the pointer to something that was autocreated + // (and the ptr just got memcpyed). + if (GPBGetHasIvarField(self, field)) { + GPBMessage *value = GPBGetObjectIvarWithFieldNoAutocreate(self, field); + GPBMessage *newValue = [value copyWithZone:zone]; + // We retain here because the memcpy picked up the pointer value and + // the next call to SetRetainedObject... will release the current value. + [value retain]; + GPBSetRetainedObjectIvarWithFieldInternal(message, field, newValue, + syntax); + } else { + uint8_t *storage = (uint8_t *)message->messageStorage_; + id *typePtr = (id *)&storage[field->description_->offset]; + *typePtr = NULL; + } + } else if (GPBFieldTypeIsObject(field) && GPBGetHasIvarField(self, field)) { + // A set string/data value (message picked off above), copy it. + id value = GPBGetObjectIvarWithFieldNoAutocreate(self, field); + id newValue = [value copyWithZone:zone]; + // We retain here because the memcpy picked up the pointer value and + // the next call to SetRetainedObject... will release the current value. + [value retain]; + GPBSetRetainedObjectIvarWithFieldInternal(message, field, newValue, + syntax); + } else { + // memcpy took care of the rest of the primative fields if they were set. + } + } // for (field in descriptor->fields_) +} + +- (id)copyWithZone:(NSZone *)zone { + GPBDescriptor *descriptor = [self descriptor]; + GPBMessage *result = [[descriptor.messageClass allocWithZone:zone] init]; + + [self copyFieldsInto:result zone:zone descriptor:descriptor]; + // Make immutable copies of the extra bits. + result->unknownFields_ = [unknownFields_ copyWithZone:zone]; + result->extensionMap_ = CloneExtensionMap(extensionMap_, zone); + return result; +} + +- (void)clear { + [self internalClear:YES]; +} + +- (void)internalClear:(BOOL)zeroStorage { + GPBDescriptor *descriptor = [self descriptor]; + for (GPBFieldDescriptor *field in descriptor->fields_) { + if (GPBFieldIsMapOrArray(field)) { + id arrayOrMap = GPBGetObjectIvarWithFieldNoAutocreate(self, field); + if (arrayOrMap) { + if (field.fieldType == GPBFieldTypeRepeated) { + if (GPBFieldTypeIsObject(field)) { + GPBAutocreatedArray *autoArray = arrayOrMap; + if (autoArray->_autocreator == self) { + autoArray->_autocreator = nil; + } + } else { + // Type doesn't matter, it is a GPB*Array. + GPBInt32Array *gpbArray = arrayOrMap; + if (gpbArray->_autocreator == self) { + gpbArray->_autocreator = nil; + } + } + } + [arrayOrMap release]; + } + } else if (GPBFieldTypeIsMessage(field)) { + GPBClearAutocreatedMessageIvarWithField(self, field); + GPBMessage *value = GPBGetObjectIvarWithFieldNoAutocreate(self, field); + [value release]; + } else if (GPBFieldTypeIsObject(field) && GPBGetHasIvarField(self, field)) { + id value = GPBGetObjectIvarWithField(self, field); + [value release]; + } + } + + // GPBClearMessageAutocreator() expects that its caller has already been + // removed from autocreatedExtensionMap_ so we set to nil first. + NSArray *autocreatedValues = [autocreatedExtensionMap_ allValues]; + [autocreatedExtensionMap_ release]; + autocreatedExtensionMap_ = nil; + + // Since we're clearing all of our extensions, make sure that we clear the + // autocreator on any that we've created so they no longer refer to us. + for (GPBMessage *value in autocreatedValues) { + NSCAssert(GPBWasMessageAutocreatedBy(value, self), + @"Autocreated extension does not refer back to self."); + GPBClearMessageAutocreator(value); + } + + [extensionMap_ release]; + extensionMap_ = nil; + [unknownFields_ release]; + unknownFields_ = nil; + + // Note that clearing does not affect autocreator_. If we are being cleared + // because of a dealloc, then autocreator_ should be nil anyway. If we are + // being cleared because someone explicitly clears us, we don't want to + // sever our relationship with our autocreator. + + if (zeroStorage) { + memset(messageStorage_, 0, descriptor->storageSize_); + } +} + +- (BOOL)isInitialized { + GPBDescriptor *descriptor = [self descriptor]; + for (GPBFieldDescriptor *field in descriptor->fields_) { + if (field.isRequired) { + if (!GPBGetHasIvarField(self, field)) { + return NO; + } + } + if (GPBFieldTypeIsMessage(field)) { + GPBFieldType fieldType = field.fieldType; + if (fieldType == GPBFieldTypeSingle) { + if (field.isRequired) { + GPBMessage *message = GPBGetMessageIvarWithField(self, field); + if (!message.initialized) { + return NO; + } + } else { + NSAssert(field.isOptional, + @"If not required or optional, what was it?"); + if (GPBGetHasIvarField(self, field)) { + GPBMessage *message = GPBGetMessageIvarWithField(self, field); + if (!message.initialized) { + return NO; + } + } + } + } else if (fieldType == GPBFieldTypeRepeated) { + NSArray *array = GPBGetObjectIvarWithFieldNoAutocreate(self, field); + for (GPBMessage *message in array) { + if (!message.initialized) { + return NO; + } + } + } else { // fieldType == GPBFieldTypeMap + if (field.mapKeyType == GPBTypeString) { + NSDictionary *map = + GPBGetObjectIvarWithFieldNoAutocreate(self, field); + if (map && !GPBDictionaryIsInitializedInternalHelper(map, field)) { + return NO; + } + } else { + // Real type is GPB*ObjectDictionary, exact type doesn't matter. + GPBInt32ObjectDictionary *map = + GPBGetObjectIvarWithFieldNoAutocreate(self, field); + if (map && ![map isInitialized]) { + return NO; + } + } + } + } + } + + __block BOOL result = YES; + [extensionMap_ + enumerateKeysAndObjectsUsingBlock:^(GPBExtensionField *extension, id obj, + BOOL *stop) { + GPBExtensionDescriptor *extDesc = extension.descriptor; + if (GPBExtensionIsMessage(extDesc)) { + if (extDesc.isRepeated) { + for (GPBMessage *msg in obj) { + if (!msg.initialized) { + result = NO; + *stop = YES; + break; + } + } + } else { + GPBMessage *asMsg = obj; + if (!asMsg.initialized) { + result = NO; + *stop = YES; + } + } + } + }]; + return result; +} + +- (GPBDescriptor *)descriptor { + return [[self class] descriptor]; +} + +- (NSData *)data { + DebugRaiseExceptionIfNotInitialized(self); + NSMutableData *data = [NSMutableData dataWithLength:[self serializedSize]]; + GPBCodedOutputStream *stream = + [[GPBCodedOutputStream alloc] initWithData:data]; + [self writeToCodedOutputStream:stream]; + [stream release]; + return data; +} + +- (NSData *)delimitedData { + size_t serializedSize = [self serializedSize]; + size_t varintSize = GPBComputeRawVarint32SizeForInteger(serializedSize); + NSMutableData *data = + [NSMutableData dataWithLength:(serializedSize + varintSize)]; + GPBCodedOutputStream *stream = + [[GPBCodedOutputStream alloc] initWithData:data]; + [self writeDelimitedToCodedOutputStream:stream]; + [stream release]; + return data; +} + +- (void)writeToOutputStream:(NSOutputStream *)output { + GPBCodedOutputStream *stream = + [[GPBCodedOutputStream alloc] initWithOutputStream:output]; + [self writeToCodedOutputStream:stream]; + [stream release]; +} + +- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)output { + GPBDescriptor *descriptor = [self descriptor]; + NSArray *fieldsArray = descriptor->fields_; + NSUInteger fieldCount = fieldsArray.count; + const GPBExtensionRange *extensionRanges = descriptor.extensionRanges; + NSUInteger extensionRangesCount = descriptor.extensionRangesCount; + for (NSUInteger i = 0, j = 0; i < fieldCount || j < extensionRangesCount;) { + if (i == fieldCount) { + [self writeExtensionsToCodedOutputStream:output + range:extensionRanges[j++]]; + } else if (j == extensionRangesCount || + GPBFieldNumber(fieldsArray[i]) < extensionRanges[j].start) { + [self writeField:fieldsArray[i++] toCodedOutputStream:output]; + } else { + [self writeExtensionsToCodedOutputStream:output + range:extensionRanges[j++]]; + } + } + if (descriptor.isWireFormat) { + [unknownFields_ writeAsMessageSetTo:output]; + } else { + [unknownFields_ writeToCodedOutputStream:output]; + } +} + +- (void)writeDelimitedToOutputStream:(NSOutputStream *)output { + GPBCodedOutputStream *codedOutput = + [[GPBCodedOutputStream alloc] initWithOutputStream:output]; + [self writeDelimitedToCodedOutputStream:codedOutput]; + [codedOutput release]; +} + +- (void)writeDelimitedToCodedOutputStream:(GPBCodedOutputStream *)output { + [output writeRawVarintSizeTAs32:[self serializedSize]]; + [self writeToCodedOutputStream:output]; +} + +- (void)writeField:(GPBFieldDescriptor *)field + toCodedOutputStream:(GPBCodedOutputStream *)output { + GPBFieldType fieldType = field.fieldType; + if (fieldType == GPBFieldTypeSingle) { + BOOL has = GPBGetHasIvarField(self, field); + if (!has) { + return; + } + } + uint32_t fieldNumber = GPBFieldNumber(field); + +//%PDDM-DEFINE FIELD_CASE(TYPE, REAL_TYPE) +//%FIELD_CASE_FULL(TYPE, REAL_TYPE, REAL_TYPE) +//%PDDM-DEFINE FIELD_CASE_FULL(TYPE, REAL_TYPE, ARRAY_TYPE) +//% case GPBType##TYPE: +//% if (fieldType == GPBFieldTypeRepeated) { +//% uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0; +//% GPB##ARRAY_TYPE##Array *array = +//% GPBGetObjectIvarWithFieldNoAutocreate(self, field); +//% [output write##TYPE##s:fieldNumber values:array tag:tag]; +//% } else if (fieldType == GPBFieldTypeSingle) { +//% [output write##TYPE:fieldNumber +//% TYPE$S value:GPBGet##REAL_TYPE##IvarWithField(self, field)]; +//% } else { // fieldType == GPBFieldTypeMap +//% // Exact type here doesn't matter. +//% GPBInt32##ARRAY_TYPE##Dictionary *dict = +//% GPBGetObjectIvarWithFieldNoAutocreate(self, field); +//% [dict writeToCodedOutputStream:output asField:field]; +//% } +//% break; +//% +//%PDDM-DEFINE FIELD_CASE2(TYPE) +//% case GPBType##TYPE: +//% if (fieldType == GPBFieldTypeRepeated) { +//% NSArray *array = GPBGetObjectIvarWithFieldNoAutocreate(self, field); +//% [output write##TYPE##s:fieldNumber values:array]; +//% } else if (fieldType == GPBFieldTypeSingle) { +//% // GPBGetObjectIvarWithFieldNoAutocreate() avoids doing the has check +//% // again. +//% [output write##TYPE:fieldNumber +//% TYPE$S value:GPBGetObjectIvarWithFieldNoAutocreate(self, field)]; +//% } else { // fieldType == GPBFieldTypeMap +//% // Exact type here doesn't matter. +//% id dict = GPBGetObjectIvarWithFieldNoAutocreate(self, field); +//% GPBType mapKeyType = field.mapKeyType; +//% if (mapKeyType == GPBTypeString) { +//% GPBDictionaryWriteToStreamInternalHelper(output, dict, field); +//% } else { +//% [dict writeToCodedOutputStream:output asField:field]; +//% } +//% } +//% break; +//% + + switch (GPBGetFieldType(field)) { + +//%PDDM-EXPAND FIELD_CASE(Bool, Bool) +// This block of code is generated, do not edit it directly. + + case GPBTypeBool: + if (fieldType == GPBFieldTypeRepeated) { + uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0; + GPBBoolArray *array = + GPBGetObjectIvarWithFieldNoAutocreate(self, field); + [output writeBools:fieldNumber values:array tag:tag]; + } else if (fieldType == GPBFieldTypeSingle) { + [output writeBool:fieldNumber + value:GPBGetBoolIvarWithField(self, field)]; + } else { // fieldType == GPBFieldTypeMap + // Exact type here doesn't matter. + GPBInt32BoolDictionary *dict = + GPBGetObjectIvarWithFieldNoAutocreate(self, field); + [dict writeToCodedOutputStream:output asField:field]; + } + break; + +//%PDDM-EXPAND FIELD_CASE(Fixed32, UInt32) +// This block of code is generated, do not edit it directly. + + case GPBTypeFixed32: + if (fieldType == GPBFieldTypeRepeated) { + uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0; + GPBUInt32Array *array = + GPBGetObjectIvarWithFieldNoAutocreate(self, field); + [output writeFixed32s:fieldNumber values:array tag:tag]; + } else if (fieldType == GPBFieldTypeSingle) { + [output writeFixed32:fieldNumber + value:GPBGetUInt32IvarWithField(self, field)]; + } else { // fieldType == GPBFieldTypeMap + // Exact type here doesn't matter. + GPBInt32UInt32Dictionary *dict = + GPBGetObjectIvarWithFieldNoAutocreate(self, field); + [dict writeToCodedOutputStream:output asField:field]; + } + break; + +//%PDDM-EXPAND FIELD_CASE(SFixed32, Int32) +// This block of code is generated, do not edit it directly. + + case GPBTypeSFixed32: + if (fieldType == GPBFieldTypeRepeated) { + uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0; + GPBInt32Array *array = + GPBGetObjectIvarWithFieldNoAutocreate(self, field); + [output writeSFixed32s:fieldNumber values:array tag:tag]; + } else if (fieldType == GPBFieldTypeSingle) { + [output writeSFixed32:fieldNumber + value:GPBGetInt32IvarWithField(self, field)]; + } else { // fieldType == GPBFieldTypeMap + // Exact type here doesn't matter. + GPBInt32Int32Dictionary *dict = + GPBGetObjectIvarWithFieldNoAutocreate(self, field); + [dict writeToCodedOutputStream:output asField:field]; + } + break; + +//%PDDM-EXPAND FIELD_CASE(Float, Float) +// This block of code is generated, do not edit it directly. + + case GPBTypeFloat: + if (fieldType == GPBFieldTypeRepeated) { + uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0; + GPBFloatArray *array = + GPBGetObjectIvarWithFieldNoAutocreate(self, field); + [output writeFloats:fieldNumber values:array tag:tag]; + } else if (fieldType == GPBFieldTypeSingle) { + [output writeFloat:fieldNumber + value:GPBGetFloatIvarWithField(self, field)]; + } else { // fieldType == GPBFieldTypeMap + // Exact type here doesn't matter. + GPBInt32FloatDictionary *dict = + GPBGetObjectIvarWithFieldNoAutocreate(self, field); + [dict writeToCodedOutputStream:output asField:field]; + } + break; + +//%PDDM-EXPAND FIELD_CASE(Fixed64, UInt64) +// This block of code is generated, do not edit it directly. + + case GPBTypeFixed64: + if (fieldType == GPBFieldTypeRepeated) { + uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0; + GPBUInt64Array *array = + GPBGetObjectIvarWithFieldNoAutocreate(self, field); + [output writeFixed64s:fieldNumber values:array tag:tag]; + } else if (fieldType == GPBFieldTypeSingle) { + [output writeFixed64:fieldNumber + value:GPBGetUInt64IvarWithField(self, field)]; + } else { // fieldType == GPBFieldTypeMap + // Exact type here doesn't matter. + GPBInt32UInt64Dictionary *dict = + GPBGetObjectIvarWithFieldNoAutocreate(self, field); + [dict writeToCodedOutputStream:output asField:field]; + } + break; + +//%PDDM-EXPAND FIELD_CASE(SFixed64, Int64) +// This block of code is generated, do not edit it directly. + + case GPBTypeSFixed64: + if (fieldType == GPBFieldTypeRepeated) { + uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0; + GPBInt64Array *array = + GPBGetObjectIvarWithFieldNoAutocreate(self, field); + [output writeSFixed64s:fieldNumber values:array tag:tag]; + } else if (fieldType == GPBFieldTypeSingle) { + [output writeSFixed64:fieldNumber + value:GPBGetInt64IvarWithField(self, field)]; + } else { // fieldType == GPBFieldTypeMap + // Exact type here doesn't matter. + GPBInt32Int64Dictionary *dict = + GPBGetObjectIvarWithFieldNoAutocreate(self, field); + [dict writeToCodedOutputStream:output asField:field]; + } + break; + +//%PDDM-EXPAND FIELD_CASE(Double, Double) +// This block of code is generated, do not edit it directly. + + case GPBTypeDouble: + if (fieldType == GPBFieldTypeRepeated) { + uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0; + GPBDoubleArray *array = + GPBGetObjectIvarWithFieldNoAutocreate(self, field); + [output writeDoubles:fieldNumber values:array tag:tag]; + } else if (fieldType == GPBFieldTypeSingle) { + [output writeDouble:fieldNumber + value:GPBGetDoubleIvarWithField(self, field)]; + } else { // fieldType == GPBFieldTypeMap + // Exact type here doesn't matter. + GPBInt32DoubleDictionary *dict = + GPBGetObjectIvarWithFieldNoAutocreate(self, field); + [dict writeToCodedOutputStream:output asField:field]; + } + break; + +//%PDDM-EXPAND FIELD_CASE(Int32, Int32) +// This block of code is generated, do not edit it directly. + + case GPBTypeInt32: + if (fieldType == GPBFieldTypeRepeated) { + uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0; + GPBInt32Array *array = + GPBGetObjectIvarWithFieldNoAutocreate(self, field); + [output writeInt32s:fieldNumber values:array tag:tag]; + } else if (fieldType == GPBFieldTypeSingle) { + [output writeInt32:fieldNumber + value:GPBGetInt32IvarWithField(self, field)]; + } else { // fieldType == GPBFieldTypeMap + // Exact type here doesn't matter. + GPBInt32Int32Dictionary *dict = + GPBGetObjectIvarWithFieldNoAutocreate(self, field); + [dict writeToCodedOutputStream:output asField:field]; + } + break; + +//%PDDM-EXPAND FIELD_CASE(Int64, Int64) +// This block of code is generated, do not edit it directly. + + case GPBTypeInt64: + if (fieldType == GPBFieldTypeRepeated) { + uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0; + GPBInt64Array *array = + GPBGetObjectIvarWithFieldNoAutocreate(self, field); + [output writeInt64s:fieldNumber values:array tag:tag]; + } else if (fieldType == GPBFieldTypeSingle) { + [output writeInt64:fieldNumber + value:GPBGetInt64IvarWithField(self, field)]; + } else { // fieldType == GPBFieldTypeMap + // Exact type here doesn't matter. + GPBInt32Int64Dictionary *dict = + GPBGetObjectIvarWithFieldNoAutocreate(self, field); + [dict writeToCodedOutputStream:output asField:field]; + } + break; + +//%PDDM-EXPAND FIELD_CASE(SInt32, Int32) +// This block of code is generated, do not edit it directly. + + case GPBTypeSInt32: + if (fieldType == GPBFieldTypeRepeated) { + uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0; + GPBInt32Array *array = + GPBGetObjectIvarWithFieldNoAutocreate(self, field); + [output writeSInt32s:fieldNumber values:array tag:tag]; + } else if (fieldType == GPBFieldTypeSingle) { + [output writeSInt32:fieldNumber + value:GPBGetInt32IvarWithField(self, field)]; + } else { // fieldType == GPBFieldTypeMap + // Exact type here doesn't matter. + GPBInt32Int32Dictionary *dict = + GPBGetObjectIvarWithFieldNoAutocreate(self, field); + [dict writeToCodedOutputStream:output asField:field]; + } + break; + +//%PDDM-EXPAND FIELD_CASE(SInt64, Int64) +// This block of code is generated, do not edit it directly. + + case GPBTypeSInt64: + if (fieldType == GPBFieldTypeRepeated) { + uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0; + GPBInt64Array *array = + GPBGetObjectIvarWithFieldNoAutocreate(self, field); + [output writeSInt64s:fieldNumber values:array tag:tag]; + } else if (fieldType == GPBFieldTypeSingle) { + [output writeSInt64:fieldNumber + value:GPBGetInt64IvarWithField(self, field)]; + } else { // fieldType == GPBFieldTypeMap + // Exact type here doesn't matter. + GPBInt32Int64Dictionary *dict = + GPBGetObjectIvarWithFieldNoAutocreate(self, field); + [dict writeToCodedOutputStream:output asField:field]; + } + break; + +//%PDDM-EXPAND FIELD_CASE(UInt32, UInt32) +// This block of code is generated, do not edit it directly. + + case GPBTypeUInt32: + if (fieldType == GPBFieldTypeRepeated) { + uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0; + GPBUInt32Array *array = + GPBGetObjectIvarWithFieldNoAutocreate(self, field); + [output writeUInt32s:fieldNumber values:array tag:tag]; + } else if (fieldType == GPBFieldTypeSingle) { + [output writeUInt32:fieldNumber + value:GPBGetUInt32IvarWithField(self, field)]; + } else { // fieldType == GPBFieldTypeMap + // Exact type here doesn't matter. + GPBInt32UInt32Dictionary *dict = + GPBGetObjectIvarWithFieldNoAutocreate(self, field); + [dict writeToCodedOutputStream:output asField:field]; + } + break; + +//%PDDM-EXPAND FIELD_CASE(UInt64, UInt64) +// This block of code is generated, do not edit it directly. + + case GPBTypeUInt64: + if (fieldType == GPBFieldTypeRepeated) { + uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0; + GPBUInt64Array *array = + GPBGetObjectIvarWithFieldNoAutocreate(self, field); + [output writeUInt64s:fieldNumber values:array tag:tag]; + } else if (fieldType == GPBFieldTypeSingle) { + [output writeUInt64:fieldNumber + value:GPBGetUInt64IvarWithField(self, field)]; + } else { // fieldType == GPBFieldTypeMap + // Exact type here doesn't matter. + GPBInt32UInt64Dictionary *dict = + GPBGetObjectIvarWithFieldNoAutocreate(self, field); + [dict writeToCodedOutputStream:output asField:field]; + } + break; + +//%PDDM-EXPAND FIELD_CASE_FULL(Enum, Int32, Enum) +// This block of code is generated, do not edit it directly. + + case GPBTypeEnum: + if (fieldType == GPBFieldTypeRepeated) { + uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0; + GPBEnumArray *array = + GPBGetObjectIvarWithFieldNoAutocreate(self, field); + [output writeEnums:fieldNumber values:array tag:tag]; + } else if (fieldType == GPBFieldTypeSingle) { + [output writeEnum:fieldNumber + value:GPBGetInt32IvarWithField(self, field)]; + } else { // fieldType == GPBFieldTypeMap + // Exact type here doesn't matter. + GPBInt32EnumDictionary *dict = + GPBGetObjectIvarWithFieldNoAutocreate(self, field); + [dict writeToCodedOutputStream:output asField:field]; + } + break; + +//%PDDM-EXPAND FIELD_CASE2(Data) +// This block of code is generated, do not edit it directly. + + case GPBTypeData: + if (fieldType == GPBFieldTypeRepeated) { + NSArray *array = GPBGetObjectIvarWithFieldNoAutocreate(self, field); + [output writeDatas:fieldNumber values:array]; + } else if (fieldType == GPBFieldTypeSingle) { + // GPBGetObjectIvarWithFieldNoAutocreate() avoids doing the has check + // again. + [output writeData:fieldNumber + value:GPBGetObjectIvarWithFieldNoAutocreate(self, field)]; + } else { // fieldType == GPBFieldTypeMap + // Exact type here doesn't matter. + id dict = GPBGetObjectIvarWithFieldNoAutocreate(self, field); + GPBType mapKeyType = field.mapKeyType; + if (mapKeyType == GPBTypeString) { + GPBDictionaryWriteToStreamInternalHelper(output, dict, field); + } else { + [dict writeToCodedOutputStream:output asField:field]; + } + } + break; + +//%PDDM-EXPAND FIELD_CASE2(String) +// This block of code is generated, do not edit it directly. + + case GPBTypeString: + if (fieldType == GPBFieldTypeRepeated) { + NSArray *array = GPBGetObjectIvarWithFieldNoAutocreate(self, field); + [output writeStrings:fieldNumber values:array]; + } else if (fieldType == GPBFieldTypeSingle) { + // GPBGetObjectIvarWithFieldNoAutocreate() avoids doing the has check + // again. + [output writeString:fieldNumber + value:GPBGetObjectIvarWithFieldNoAutocreate(self, field)]; + } else { // fieldType == GPBFieldTypeMap + // Exact type here doesn't matter. + id dict = GPBGetObjectIvarWithFieldNoAutocreate(self, field); + GPBType mapKeyType = field.mapKeyType; + if (mapKeyType == GPBTypeString) { + GPBDictionaryWriteToStreamInternalHelper(output, dict, field); + } else { + [dict writeToCodedOutputStream:output asField:field]; + } + } + break; + +//%PDDM-EXPAND FIELD_CASE2(Message) +// This block of code is generated, do not edit it directly. + + case GPBTypeMessage: + if (fieldType == GPBFieldTypeRepeated) { + NSArray *array = GPBGetObjectIvarWithFieldNoAutocreate(self, field); + [output writeMessages:fieldNumber values:array]; + } else if (fieldType == GPBFieldTypeSingle) { + // GPBGetObjectIvarWithFieldNoAutocreate() avoids doing the has check + // again. + [output writeMessage:fieldNumber + value:GPBGetObjectIvarWithFieldNoAutocreate(self, field)]; + } else { // fieldType == GPBFieldTypeMap + // Exact type here doesn't matter. + id dict = GPBGetObjectIvarWithFieldNoAutocreate(self, field); + GPBType mapKeyType = field.mapKeyType; + if (mapKeyType == GPBTypeString) { + GPBDictionaryWriteToStreamInternalHelper(output, dict, field); + } else { + [dict writeToCodedOutputStream:output asField:field]; + } + } + break; + +//%PDDM-EXPAND FIELD_CASE2(Group) +// This block of code is generated, do not edit it directly. + + case GPBTypeGroup: + if (fieldType == GPBFieldTypeRepeated) { + NSArray *array = GPBGetObjectIvarWithFieldNoAutocreate(self, field); + [output writeGroups:fieldNumber values:array]; + } else if (fieldType == GPBFieldTypeSingle) { + // GPBGetObjectIvarWithFieldNoAutocreate() avoids doing the has check + // again. + [output writeGroup:fieldNumber + value:GPBGetObjectIvarWithFieldNoAutocreate(self, field)]; + } else { // fieldType == GPBFieldTypeMap + // Exact type here doesn't matter. + id dict = GPBGetObjectIvarWithFieldNoAutocreate(self, field); + GPBType mapKeyType = field.mapKeyType; + if (mapKeyType == GPBTypeString) { + GPBDictionaryWriteToStreamInternalHelper(output, dict, field); + } else { + [dict writeToCodedOutputStream:output asField:field]; + } + } + break; + +//%PDDM-EXPAND-END (18 expansions) + } +} + +#pragma mark - Extensions + +- (id)getExtension:(GPBExtensionField *)extension { + CheckExtension(self, extension); + id value = [extensionMap_ objectForKey:extension]; + if (value != nil) { + return value; + } + + GPBExtensionDescriptor *extDesc = extension.descriptor; + + // No default for repeated. + if (extDesc.isRepeated) { + return nil; + } + // Non messages get their default. + if (!GPBExtensionIsMessage(extDesc)) { + return [extension defaultValue]; + } + + // Check for an autocreated value. + OSSpinLockLock(&readOnlyMutex_); + value = [autocreatedExtensionMap_ objectForKey:extension]; + if (!value) { + // Auto create the message extensions to match normal fields. + value = CreateMessageWithAutocreatorForExtension(extDesc.msgClass, self, + extension); + + if (autocreatedExtensionMap_ == nil) { + autocreatedExtensionMap_ = [[NSMutableDictionary alloc] init]; + } + + // We can't simply call setExtension here because that would clear the new + // value's autocreator. + [autocreatedExtensionMap_ setObject:value forKey:extension]; + [value release]; + } + + OSSpinLockUnlock(&readOnlyMutex_); + return value; +} + +- (id)getExistingExtension:(GPBExtensionField *)extension { + // This is an internal method so we don't need to call CheckExtension(). + return [extensionMap_ objectForKey:extension]; +} + +- (BOOL)hasExtension:(GPBExtensionField *)extension { +#if DEBUG + CheckExtension(self, extension); +#endif // DEBUG + return nil != [extensionMap_ objectForKey:extension]; +} + +- (NSArray *)extensionsCurrentlySet { + return [extensionMap_ allKeys]; +} + +- (void)writeExtensionsToCodedOutputStream:(GPBCodedOutputStream *)output + range:(GPBExtensionRange)range { + NSArray *sortedExtensions = [[extensionMap_ allKeys] + sortedArrayUsingSelector:@selector(compareByFieldNumber:)]; + uint32_t start = range.start; + uint32_t end = range.end; + for (GPBExtensionField *extension in sortedExtensions) { + uint32_t fieldNumber = [extension fieldNumber]; + if (fieldNumber >= start && fieldNumber < end) { + id value = [extensionMap_ objectForKey:extension]; + [extension writeValue:value includingTagToCodedOutputStream:output]; + } + } +} + +- (NSArray *)sortedExtensionsInUse { + return [[extensionMap_ allKeys] + sortedArrayUsingSelector:@selector(compareByFieldNumber:)]; +} + +- (void)setExtension:(GPBExtensionField *)extension value:(id)value { + if (!value) { + [self clearExtension:extension]; + return; + } + + CheckExtension(self, extension); + + if ([extension isRepeated]) { + [NSException raise:NSInvalidArgumentException + format:@"Must call addExtension() for repeated types."]; + } + + if (extensionMap_ == nil) { + extensionMap_ = [[NSMutableDictionary alloc] init]; + } + + [extensionMap_ setObject:value forKey:extension]; + + GPBExtensionDescriptor *descriptor = extension.descriptor; + + if (GPBExtensionIsMessage(descriptor) && !descriptor.isRepeated) { + GPBMessage *autocreatedValue = + [[autocreatedExtensionMap_ objectForKey:extension] retain]; + // Must remove from the map before calling GPBClearMessageAutocreator() so + // that GPBClearMessageAutocreator() knows its safe to clear. + [autocreatedExtensionMap_ removeObjectForKey:extension]; + GPBClearMessageAutocreator(autocreatedValue); + [autocreatedValue release]; + } + + GPBBecomeVisibleToAutocreator(self); +} + +- (void)addExtension:(GPBExtensionField *)extension value:(id)value { + CheckExtension(self, extension); + + if (![extension isRepeated]) { + [NSException raise:NSInvalidArgumentException + format:@"Must call setExtension() for singular types."]; + } + + if (extensionMap_ == nil) { + extensionMap_ = [[NSMutableDictionary alloc] init]; + } + NSMutableArray *list = [extensionMap_ objectForKey:extension]; + if (list == nil) { + list = [NSMutableArray array]; + [extensionMap_ setObject:list forKey:extension]; + } + + [list addObject:value]; + GPBBecomeVisibleToAutocreator(self); +} + +- (void)setExtension:(GPBExtensionField *)extension + index:(NSUInteger)idx + value:(id)value { + CheckExtension(self, extension); + + if (![extension isRepeated]) { + [NSException raise:NSInvalidArgumentException + format:@"Must call setExtension() for singular types."]; + } + + if (extensionMap_ == nil) { + extensionMap_ = [[NSMutableDictionary alloc] init]; + } + + NSMutableArray *list = [extensionMap_ objectForKey:extension]; + + [list replaceObjectAtIndex:idx withObject:value]; + GPBBecomeVisibleToAutocreator(self); +} + +- (void)clearExtension:(GPBExtensionField *)extension { + CheckExtension(self, extension); + + // Only become visible if there was actually a value to clear. + if ([extensionMap_ objectForKey:extension]) { + [extensionMap_ removeObjectForKey:extension]; + GPBBecomeVisibleToAutocreator(self); + } +} + +#pragma mark - mergeFrom + +- (void)mergeFromData:(NSData *)data + extensionRegistry:(GPBExtensionRegistry *)extensionRegistry { + GPBCodedInputStream *input = [[GPBCodedInputStream alloc] initWithData:data]; + [self mergeFromCodedInputStream:input extensionRegistry:extensionRegistry]; + [input checkLastTagWas:0]; + [input release]; +} + +#pragma mark - mergeDelimitedFrom + +- (void)mergeDelimitedFromCodedInputStream:(GPBCodedInputStream *)input + extensionRegistry:(GPBExtensionRegistry *)extensionRegistry { + GPBCodedInputStreamState *state = &input->state_; + if (GPBCodedInputStreamIsAtEnd(state)) { + return; + } + NSData *data = GPBCodedInputStreamReadRetainedDataNoCopy(state); + if (data == nil) { + return; + } + [self mergeFromData:data extensionRegistry:extensionRegistry]; + [data release]; +} + +#pragma mark - Parse From Data Support + ++ (instancetype)parseFromData:(NSData *)data { + return [self parseFromData:data extensionRegistry:nil]; +} + ++ (instancetype)parseFromData:(NSData *)data + extensionRegistry:(GPBExtensionRegistry *)extensionRegistry { + return [[[self alloc] initWithData:data + extensionRegistry:extensionRegistry] autorelease]; +} + ++ (instancetype)parseFromCodedInputStream:(GPBCodedInputStream *)input + extensionRegistry:(GPBExtensionRegistry *)extensionRegistry { + return + [[[self alloc] initWithCodedInputStream:input + extensionRegistry:extensionRegistry] autorelease]; +} + +#pragma mark - Parse Delimited From Data Support + ++ (instancetype)parseDelimitedFromCodedInputStream:(GPBCodedInputStream *)input + extensionRegistry: + (GPBExtensionRegistry *)extensionRegistry { + GPBMessage *message = [[[self alloc] init] autorelease]; + [message mergeDelimitedFromCodedInputStream:input + extensionRegistry:extensionRegistry]; + DebugRaiseExceptionIfNotInitialized(message); + return message; +} + +#pragma mark - Unknown Field Support + +- (GPBUnknownFieldSet *)unknownFields { + return unknownFields_; +} + +- (void)setUnknownFields:(GPBUnknownFieldSet *)unknownFields { + if (unknownFields != unknownFields_) { + [unknownFields_ release]; + unknownFields_ = [unknownFields copy]; + GPBBecomeVisibleToAutocreator(self); + } +} + +- (void)parseMessageSet:(GPBCodedInputStream *)input + extensionRegistry:(GPBExtensionRegistry *)extensionRegistry { + uint32_t typeId = 0; + NSData *rawBytes = nil; + GPBExtensionField *extension = nil; + GPBCodedInputStreamState *state = &input->state_; + while (true) { + uint32_t tag = GPBCodedInputStreamReadTag(state); + if (tag == 0) { + break; + } + + if (tag == GPBWireFormatMessageSetTypeIdTag) { + typeId = GPBCodedInputStreamReadUInt32(state); + if (typeId != 0) { + extension = [extensionRegistry getExtension:[self descriptor] + fieldNumber:typeId]; + } + } else if (tag == GPBWireFormatMessageSetMessageTag) { + rawBytes = [GPBCodedInputStreamReadRetainedDataNoCopy(state) autorelease]; + } else { + if (![input skipField:tag]) { + break; + } + } + } + + [input checkLastTagWas:GPBWireFormatMessageSetItemEndTag]; + + if (rawBytes != nil && typeId != 0) { + if (extension != nil) { + GPBCodedInputStream *newInput = + [[GPBCodedInputStream alloc] initWithData:rawBytes]; + [extension mergeFromCodedInputStream:newInput + extensionRegistry:extensionRegistry + message:self]; + [newInput release]; + } else { + GPBUnknownFieldSet *unknownFields = GetOrMakeUnknownFields(self); + [unknownFields mergeMessageSetMessage:typeId data:rawBytes]; + } + } +} + +- (BOOL)parseUnknownField:(GPBCodedInputStream *)input + extensionRegistry:(GPBExtensionRegistry *)extensionRegistry + tag:(uint32_t)tag { + GPBWireFormat wireType = GPBWireFormatGetTagWireType(tag); + int32_t fieldNumber = GPBWireFormatGetTagFieldNumber(tag); + + GPBDescriptor *descriptor = [self descriptor]; + GPBExtensionField *extension = + [extensionRegistry getExtension:descriptor fieldNumber:fieldNumber]; + + if (extension == nil) { + if (descriptor.wireFormat && GPBWireFormatMessageSetItemTag == tag) { + [self parseMessageSet:input extensionRegistry:extensionRegistry]; + return YES; + } + } else { + if ([extension wireType] == wireType) { + [extension mergeFromCodedInputStream:input + extensionRegistry:extensionRegistry + message:self]; + return YES; + } + } + if ([GPBUnknownFieldSet isFieldTag:tag]) { + GPBUnknownFieldSet *unknownFields = GetOrMakeUnknownFields(self); + return [unknownFields mergeFieldFrom:tag input:input]; + } else { + return NO; + } +} + +- (void)addUnknownMapEntry:(int32_t)fieldNum value:(NSData *)data { + GPBUnknownFieldSet *unknownFields = GetOrMakeUnknownFields(self); + [unknownFields addUnknownMapEntry:fieldNum value:data]; +} + +#pragma mark - MergeFromCodedInputStream Support + +typedef struct MergeFromCodedInputStreamContext { + GPBMessage *self; + GPBCodedInputStream *stream; + GPBMessage *result; + GPBExtensionRegistry *registry; + uint32_t tag; + GPBFileSyntax syntax; +} MergeFromCodedInputStreamContext; + +//%PDDM-DEFINE MERGE_FROM_CODED_INPUT_STREAM_POD_FUNC(NAME, TYPE, ARRAY_TYPE) +//%static BOOL DynamicMergeFromCodedInputStream##NAME(GPBFieldDescriptor *field, +//% NAME$S void *voidContext) { +//% MergeFromCodedInputStreamContext *context = +//% (MergeFromCodedInputStreamContext *)voidContext; +//% GPBCodedInputStreamState *state = &context->stream->state_; +//% GPBFieldType fieldType = field.fieldType; +//% if (fieldType == GPBFieldTypeRepeated) { +//% GPB##ARRAY_TYPE##Array *array = +//% GetOrCreateArrayIvarWithField(context->result, field, context->syntax); +//% if (field.isPackable) { +//% int32_t length = GPBCodedInputStreamReadInt32(state); +//% size_t limit = GPBCodedInputStreamPushLimit(state, length); +//% while (GPBCodedInputStreamBytesUntilLimit(state) > 0) { +//% TYPE val = GPBCodedInputStreamRead##NAME(state); +//% [array addValue:val]; +//% } +//% GPBCodedInputStreamPopLimit(state, limit); +//% } else { +//% TYPE val = GPBCodedInputStreamRead##NAME(state); +//% [array addValue:val]; +//% } +//% } else if (fieldType == GPBFieldTypeSingle) { +//% TYPE val = GPBCodedInputStreamRead##NAME(state); +//% GPBSet##ARRAY_TYPE##IvarWithFieldInternal(context->result, field, val, +//% ARRAY_TYPE$S context->syntax); +//% } else { // fieldType == GPBFieldTypeMap +//% // The exact type doesn't matter, just need to know it is a GPB*Dictionary. +//% GPBInt32Int32Dictionary *map = +//% GetOrCreateMapIvarWithField(context->result, field, context->syntax); +//% [context->stream readMapEntry:map +//% extensionRegistry:nil +//% field:field +//% parentMessage:context->result]; +//% } +//% return NO; +//%} +//% +//%PDDM-DEFINE MERGE_FROM_CODED_INPUT_STREAM_OBJ_FUNC(NAME) +//%static BOOL DynamicMergeFromCodedInputStream##NAME(GPBFieldDescriptor *field, +//% NAME$S void *voidContext) { +//% MergeFromCodedInputStreamContext *context = voidContext; +//% GPBCodedInputStreamState *state = &context->stream->state_; +//% GPBFieldType fieldType = field.fieldType; +//% if (fieldType == GPBFieldTypeMap) { +//% // GPB*Dictionary or NSDictionary, exact type doesn't matter at this point. +//% id map = +//% GetOrCreateMapIvarWithField(context->result, field, context->syntax); +//% [context->stream readMapEntry:map +//% extensionRegistry:nil +//% field:field +//% parentMessage:context->result]; +//% } else { +//% id val = GPBCodedInputStreamReadRetained##NAME(state); +//% if (fieldType == GPBFieldTypeRepeated) { +//% NSMutableArray *array = +//% GetOrCreateArrayIvarWithField(context->result, field, context->syntax); +//% [array addObject:val]; +//% [val release]; +//% } else { // fieldType == GPBFieldTypeSingle +//% GPBSetRetainedObjectIvarWithFieldInternal(context->result, field, val, +//% context->syntax); +//% } +//% } +//% return NO; +//%} +//% + +static BOOL DynamicMergeFromCodedInputStreamGroup(GPBFieldDescriptor *field, + void *voidContext) { + MergeFromCodedInputStreamContext *context = + (MergeFromCodedInputStreamContext *)voidContext; + int number = GPBFieldNumber(field); + GPBFieldType fieldType = field.fieldType; + if (fieldType == GPBFieldTypeRepeated) { + GPBMessage *message = [[field.msgClass alloc] init]; + NSMutableArray *array = + GetOrCreateArrayIvarWithField(context->result, field, context->syntax); + [context->stream readGroup:number + message:message + extensionRegistry:context->registry]; + [array addObject:message]; + [message release]; + } else if (fieldType == GPBFieldTypeSingle) { + BOOL has = GPBGetHasIvarField(context->result, field); + if (has) { + // GPBGetObjectIvarWithFieldNoAutocreate() avoids doing the has check + // again. + GPBMessage *message = + GPBGetObjectIvarWithFieldNoAutocreate(context->result, field); + [context->stream readGroup:number + message:message + extensionRegistry:context->registry]; + } else { + GPBMessage *message = [[field.msgClass alloc] init]; + [context->stream readGroup:number + message:message + extensionRegistry:context->registry]; + GPBSetRetainedObjectIvarWithFieldInternal(context->result, field, message, + context->syntax); + } + } else { // fieldType == GPBFieldTypeMap + NSCAssert(NO, @"Shouldn't happen"); + return YES; + } + return NO; +} + +static BOOL DynamicMergeFromCodedInputStreamMessage(GPBFieldDescriptor *field, + void *voidContext) { + MergeFromCodedInputStreamContext *context = + (MergeFromCodedInputStreamContext *)voidContext; + GPBFieldType fieldType = field.fieldType; + if (fieldType == GPBFieldTypeRepeated) { + GPBMessage *message = [[field.msgClass alloc] init]; + NSMutableArray *array = + GetOrCreateArrayIvarWithField(context->result, field, context->syntax); + [context->stream readMessage:message extensionRegistry:context->registry]; + [array addObject:message]; + [message release]; + } else if (fieldType == GPBFieldTypeSingle) { + BOOL has = GPBGetHasIvarField(context->result, field); + if (has) { + // GPBGetObjectIvarWithFieldNoAutocreate() avoids doing the has check + // again. + GPBMessage *message = + GPBGetObjectIvarWithFieldNoAutocreate(context->result, field); + [context->stream readMessage:message extensionRegistry:context->registry]; + } else { + GPBMessage *message = [[field.msgClass alloc] init]; + [context->stream readMessage:message extensionRegistry:context->registry]; + GPBSetRetainedObjectIvarWithFieldInternal(context->result, field, message, + context->syntax); + } + } else { // fieldType == GPBFieldTypeMap + // GPB*Dictionary or NSDictionary, exact type doesn't matter. + id map = + GetOrCreateMapIvarWithField(context->result, field, context->syntax); + [context->stream readMapEntry:map + extensionRegistry:context->registry + field:field + parentMessage:context->result]; + } + return NO; +} + +static BOOL DynamicMergeFromCodedInputStreamEnum(GPBFieldDescriptor *field, + void *voidContext) { + MergeFromCodedInputStreamContext *context = + (MergeFromCodedInputStreamContext *)voidContext; + int number = GPBFieldNumber(field); + BOOL hasPreservingUnknownEnumSemantics = + GPBHasPreservingUnknownEnumSemantics(context->syntax); + GPBCodedInputStreamState *state = &context->stream->state_; + GPBFieldType fieldType = field.fieldType; + if (fieldType == GPBFieldTypeRepeated) { + GPBEnumArray *array = + GetOrCreateArrayIvarWithField(context->result, field, context->syntax); + if (field.isPackable) { + int32_t length = GPBCodedInputStreamReadInt32(state); + size_t limit = GPBCodedInputStreamPushLimit(state, length); + while (GPBCodedInputStreamBytesUntilLimit(state) > 0) { + int32_t val = GPBCodedInputStreamReadEnum(state); + if (hasPreservingUnknownEnumSemantics || [field isValidEnumValue:val]) { + [array addRawValue:val]; + } else { + GPBUnknownFieldSet *unknownFields = + GetOrMakeUnknownFields(context->self); + [unknownFields mergeVarintField:number value:val]; + } + } + GPBCodedInputStreamPopLimit(state, limit); + } else { + int32_t val = GPBCodedInputStreamReadEnum(state); + if (hasPreservingUnknownEnumSemantics || [field isValidEnumValue:val]) { + [array addRawValue:val]; + } else { + GPBUnknownFieldSet *unknownFields = + GetOrMakeUnknownFields(context->self); + [unknownFields mergeVarintField:number value:val]; + } + } + } else if (fieldType == GPBFieldTypeSingle) { + int32_t val = GPBCodedInputStreamReadEnum(state); + if (hasPreservingUnknownEnumSemantics || [field isValidEnumValue:val]) { + GPBSetInt32IvarWithFieldInternal(context->result, field, val, + context->syntax); + } else { + GPBUnknownFieldSet *unknownFields = GetOrMakeUnknownFields(context->self); + [unknownFields mergeVarintField:number value:val]; + } + } else { // fieldType == GPBFieldTypeMap + // The exact type doesn't matter, just need to know it is a + // GPB*EnumDictionary. + GPBInt32EnumDictionary *map = + GetOrCreateMapIvarWithField(context->result, field, context->syntax); + [context->stream readMapEntry:map + extensionRegistry:context->registry + field:field + parentMessage:context->result]; + } + return NO; +} + +//%PDDM-EXPAND MERGE_FROM_CODED_INPUT_STREAM_POD_FUNC(Bool, BOOL, Bool) +// This block of code is generated, do not edit it directly. + +static BOOL DynamicMergeFromCodedInputStreamBool(GPBFieldDescriptor *field, + void *voidContext) { + MergeFromCodedInputStreamContext *context = + (MergeFromCodedInputStreamContext *)voidContext; + GPBCodedInputStreamState *state = &context->stream->state_; + GPBFieldType fieldType = field.fieldType; + if (fieldType == GPBFieldTypeRepeated) { + GPBBoolArray *array = + GetOrCreateArrayIvarWithField(context->result, field, context->syntax); + if (field.isPackable) { + int32_t length = GPBCodedInputStreamReadInt32(state); + size_t limit = GPBCodedInputStreamPushLimit(state, length); + while (GPBCodedInputStreamBytesUntilLimit(state) > 0) { + BOOL val = GPBCodedInputStreamReadBool(state); + [array addValue:val]; + } + GPBCodedInputStreamPopLimit(state, limit); + } else { + BOOL val = GPBCodedInputStreamReadBool(state); + [array addValue:val]; + } + } else if (fieldType == GPBFieldTypeSingle) { + BOOL val = GPBCodedInputStreamReadBool(state); + GPBSetBoolIvarWithFieldInternal(context->result, field, val, + context->syntax); + } else { // fieldType == GPBFieldTypeMap + // The exact type doesn't matter, just need to know it is a GPB*Dictionary. + GPBInt32Int32Dictionary *map = + GetOrCreateMapIvarWithField(context->result, field, context->syntax); + [context->stream readMapEntry:map + extensionRegistry:nil + field:field + parentMessage:context->result]; + } + return NO; +} + +//%PDDM-EXPAND MERGE_FROM_CODED_INPUT_STREAM_POD_FUNC(Int32, int32_t, Int32) +// This block of code is generated, do not edit it directly. + +static BOOL DynamicMergeFromCodedInputStreamInt32(GPBFieldDescriptor *field, + void *voidContext) { + MergeFromCodedInputStreamContext *context = + (MergeFromCodedInputStreamContext *)voidContext; + GPBCodedInputStreamState *state = &context->stream->state_; + GPBFieldType fieldType = field.fieldType; + if (fieldType == GPBFieldTypeRepeated) { + GPBInt32Array *array = + GetOrCreateArrayIvarWithField(context->result, field, context->syntax); + if (field.isPackable) { + int32_t length = GPBCodedInputStreamReadInt32(state); + size_t limit = GPBCodedInputStreamPushLimit(state, length); + while (GPBCodedInputStreamBytesUntilLimit(state) > 0) { + int32_t val = GPBCodedInputStreamReadInt32(state); + [array addValue:val]; + } + GPBCodedInputStreamPopLimit(state, limit); + } else { + int32_t val = GPBCodedInputStreamReadInt32(state); + [array addValue:val]; + } + } else if (fieldType == GPBFieldTypeSingle) { + int32_t val = GPBCodedInputStreamReadInt32(state); + GPBSetInt32IvarWithFieldInternal(context->result, field, val, + context->syntax); + } else { // fieldType == GPBFieldTypeMap + // The exact type doesn't matter, just need to know it is a GPB*Dictionary. + GPBInt32Int32Dictionary *map = + GetOrCreateMapIvarWithField(context->result, field, context->syntax); + [context->stream readMapEntry:map + extensionRegistry:nil + field:field + parentMessage:context->result]; + } + return NO; +} + +//%PDDM-EXPAND MERGE_FROM_CODED_INPUT_STREAM_POD_FUNC(SInt32, int32_t, Int32) +// This block of code is generated, do not edit it directly. + +static BOOL DynamicMergeFromCodedInputStreamSInt32(GPBFieldDescriptor *field, + void *voidContext) { + MergeFromCodedInputStreamContext *context = + (MergeFromCodedInputStreamContext *)voidContext; + GPBCodedInputStreamState *state = &context->stream->state_; + GPBFieldType fieldType = field.fieldType; + if (fieldType == GPBFieldTypeRepeated) { + GPBInt32Array *array = + GetOrCreateArrayIvarWithField(context->result, field, context->syntax); + if (field.isPackable) { + int32_t length = GPBCodedInputStreamReadInt32(state); + size_t limit = GPBCodedInputStreamPushLimit(state, length); + while (GPBCodedInputStreamBytesUntilLimit(state) > 0) { + int32_t val = GPBCodedInputStreamReadSInt32(state); + [array addValue:val]; + } + GPBCodedInputStreamPopLimit(state, limit); + } else { + int32_t val = GPBCodedInputStreamReadSInt32(state); + [array addValue:val]; + } + } else if (fieldType == GPBFieldTypeSingle) { + int32_t val = GPBCodedInputStreamReadSInt32(state); + GPBSetInt32IvarWithFieldInternal(context->result, field, val, + context->syntax); + } else { // fieldType == GPBFieldTypeMap + // The exact type doesn't matter, just need to know it is a GPB*Dictionary. + GPBInt32Int32Dictionary *map = + GetOrCreateMapIvarWithField(context->result, field, context->syntax); + [context->stream readMapEntry:map + extensionRegistry:nil + field:field + parentMessage:context->result]; + } + return NO; +} + +//%PDDM-EXPAND MERGE_FROM_CODED_INPUT_STREAM_POD_FUNC(SFixed32, int32_t, Int32) +// This block of code is generated, do not edit it directly. + +static BOOL DynamicMergeFromCodedInputStreamSFixed32(GPBFieldDescriptor *field, + void *voidContext) { + MergeFromCodedInputStreamContext *context = + (MergeFromCodedInputStreamContext *)voidContext; + GPBCodedInputStreamState *state = &context->stream->state_; + GPBFieldType fieldType = field.fieldType; + if (fieldType == GPBFieldTypeRepeated) { + GPBInt32Array *array = + GetOrCreateArrayIvarWithField(context->result, field, context->syntax); + if (field.isPackable) { + int32_t length = GPBCodedInputStreamReadInt32(state); + size_t limit = GPBCodedInputStreamPushLimit(state, length); + while (GPBCodedInputStreamBytesUntilLimit(state) > 0) { + int32_t val = GPBCodedInputStreamReadSFixed32(state); + [array addValue:val]; + } + GPBCodedInputStreamPopLimit(state, limit); + } else { + int32_t val = GPBCodedInputStreamReadSFixed32(state); + [array addValue:val]; + } + } else if (fieldType == GPBFieldTypeSingle) { + int32_t val = GPBCodedInputStreamReadSFixed32(state); + GPBSetInt32IvarWithFieldInternal(context->result, field, val, + context->syntax); + } else { // fieldType == GPBFieldTypeMap + // The exact type doesn't matter, just need to know it is a GPB*Dictionary. + GPBInt32Int32Dictionary *map = + GetOrCreateMapIvarWithField(context->result, field, context->syntax); + [context->stream readMapEntry:map + extensionRegistry:nil + field:field + parentMessage:context->result]; + } + return NO; +} + +//%PDDM-EXPAND MERGE_FROM_CODED_INPUT_STREAM_POD_FUNC(UInt32, uint32_t, UInt32) +// This block of code is generated, do not edit it directly. + +static BOOL DynamicMergeFromCodedInputStreamUInt32(GPBFieldDescriptor *field, + void *voidContext) { + MergeFromCodedInputStreamContext *context = + (MergeFromCodedInputStreamContext *)voidContext; + GPBCodedInputStreamState *state = &context->stream->state_; + GPBFieldType fieldType = field.fieldType; + if (fieldType == GPBFieldTypeRepeated) { + GPBUInt32Array *array = + GetOrCreateArrayIvarWithField(context->result, field, context->syntax); + if (field.isPackable) { + int32_t length = GPBCodedInputStreamReadInt32(state); + size_t limit = GPBCodedInputStreamPushLimit(state, length); + while (GPBCodedInputStreamBytesUntilLimit(state) > 0) { + uint32_t val = GPBCodedInputStreamReadUInt32(state); + [array addValue:val]; + } + GPBCodedInputStreamPopLimit(state, limit); + } else { + uint32_t val = GPBCodedInputStreamReadUInt32(state); + [array addValue:val]; + } + } else if (fieldType == GPBFieldTypeSingle) { + uint32_t val = GPBCodedInputStreamReadUInt32(state); + GPBSetUInt32IvarWithFieldInternal(context->result, field, val, + context->syntax); + } else { // fieldType == GPBFieldTypeMap + // The exact type doesn't matter, just need to know it is a GPB*Dictionary. + GPBInt32Int32Dictionary *map = + GetOrCreateMapIvarWithField(context->result, field, context->syntax); + [context->stream readMapEntry:map + extensionRegistry:nil + field:field + parentMessage:context->result]; + } + return NO; +} + +//%PDDM-EXPAND MERGE_FROM_CODED_INPUT_STREAM_POD_FUNC(Fixed32, uint32_t, UInt32) +// This block of code is generated, do not edit it directly. + +static BOOL DynamicMergeFromCodedInputStreamFixed32(GPBFieldDescriptor *field, + void *voidContext) { + MergeFromCodedInputStreamContext *context = + (MergeFromCodedInputStreamContext *)voidContext; + GPBCodedInputStreamState *state = &context->stream->state_; + GPBFieldType fieldType = field.fieldType; + if (fieldType == GPBFieldTypeRepeated) { + GPBUInt32Array *array = + GetOrCreateArrayIvarWithField(context->result, field, context->syntax); + if (field.isPackable) { + int32_t length = GPBCodedInputStreamReadInt32(state); + size_t limit = GPBCodedInputStreamPushLimit(state, length); + while (GPBCodedInputStreamBytesUntilLimit(state) > 0) { + uint32_t val = GPBCodedInputStreamReadFixed32(state); + [array addValue:val]; + } + GPBCodedInputStreamPopLimit(state, limit); + } else { + uint32_t val = GPBCodedInputStreamReadFixed32(state); + [array addValue:val]; + } + } else if (fieldType == GPBFieldTypeSingle) { + uint32_t val = GPBCodedInputStreamReadFixed32(state); + GPBSetUInt32IvarWithFieldInternal(context->result, field, val, + context->syntax); + } else { // fieldType == GPBFieldTypeMap + // The exact type doesn't matter, just need to know it is a GPB*Dictionary. + GPBInt32Int32Dictionary *map = + GetOrCreateMapIvarWithField(context->result, field, context->syntax); + [context->stream readMapEntry:map + extensionRegistry:nil + field:field + parentMessage:context->result]; + } + return NO; +} + +//%PDDM-EXPAND MERGE_FROM_CODED_INPUT_STREAM_POD_FUNC(Int64, int64_t, Int64) +// This block of code is generated, do not edit it directly. + +static BOOL DynamicMergeFromCodedInputStreamInt64(GPBFieldDescriptor *field, + void *voidContext) { + MergeFromCodedInputStreamContext *context = + (MergeFromCodedInputStreamContext *)voidContext; + GPBCodedInputStreamState *state = &context->stream->state_; + GPBFieldType fieldType = field.fieldType; + if (fieldType == GPBFieldTypeRepeated) { + GPBInt64Array *array = + GetOrCreateArrayIvarWithField(context->result, field, context->syntax); + if (field.isPackable) { + int32_t length = GPBCodedInputStreamReadInt32(state); + size_t limit = GPBCodedInputStreamPushLimit(state, length); + while (GPBCodedInputStreamBytesUntilLimit(state) > 0) { + int64_t val = GPBCodedInputStreamReadInt64(state); + [array addValue:val]; + } + GPBCodedInputStreamPopLimit(state, limit); + } else { + int64_t val = GPBCodedInputStreamReadInt64(state); + [array addValue:val]; + } + } else if (fieldType == GPBFieldTypeSingle) { + int64_t val = GPBCodedInputStreamReadInt64(state); + GPBSetInt64IvarWithFieldInternal(context->result, field, val, + context->syntax); + } else { // fieldType == GPBFieldTypeMap + // The exact type doesn't matter, just need to know it is a GPB*Dictionary. + GPBInt32Int32Dictionary *map = + GetOrCreateMapIvarWithField(context->result, field, context->syntax); + [context->stream readMapEntry:map + extensionRegistry:nil + field:field + parentMessage:context->result]; + } + return NO; +} + +//%PDDM-EXPAND MERGE_FROM_CODED_INPUT_STREAM_POD_FUNC(SFixed64, int64_t, Int64) +// This block of code is generated, do not edit it directly. + +static BOOL DynamicMergeFromCodedInputStreamSFixed64(GPBFieldDescriptor *field, + void *voidContext) { + MergeFromCodedInputStreamContext *context = + (MergeFromCodedInputStreamContext *)voidContext; + GPBCodedInputStreamState *state = &context->stream->state_; + GPBFieldType fieldType = field.fieldType; + if (fieldType == GPBFieldTypeRepeated) { + GPBInt64Array *array = + GetOrCreateArrayIvarWithField(context->result, field, context->syntax); + if (field.isPackable) { + int32_t length = GPBCodedInputStreamReadInt32(state); + size_t limit = GPBCodedInputStreamPushLimit(state, length); + while (GPBCodedInputStreamBytesUntilLimit(state) > 0) { + int64_t val = GPBCodedInputStreamReadSFixed64(state); + [array addValue:val]; + } + GPBCodedInputStreamPopLimit(state, limit); + } else { + int64_t val = GPBCodedInputStreamReadSFixed64(state); + [array addValue:val]; + } + } else if (fieldType == GPBFieldTypeSingle) { + int64_t val = GPBCodedInputStreamReadSFixed64(state); + GPBSetInt64IvarWithFieldInternal(context->result, field, val, + context->syntax); + } else { // fieldType == GPBFieldTypeMap + // The exact type doesn't matter, just need to know it is a GPB*Dictionary. + GPBInt32Int32Dictionary *map = + GetOrCreateMapIvarWithField(context->result, field, context->syntax); + [context->stream readMapEntry:map + extensionRegistry:nil + field:field + parentMessage:context->result]; + } + return NO; +} + +//%PDDM-EXPAND MERGE_FROM_CODED_INPUT_STREAM_POD_FUNC(SInt64, int64_t, Int64) +// This block of code is generated, do not edit it directly. + +static BOOL DynamicMergeFromCodedInputStreamSInt64(GPBFieldDescriptor *field, + void *voidContext) { + MergeFromCodedInputStreamContext *context = + (MergeFromCodedInputStreamContext *)voidContext; + GPBCodedInputStreamState *state = &context->stream->state_; + GPBFieldType fieldType = field.fieldType; + if (fieldType == GPBFieldTypeRepeated) { + GPBInt64Array *array = + GetOrCreateArrayIvarWithField(context->result, field, context->syntax); + if (field.isPackable) { + int32_t length = GPBCodedInputStreamReadInt32(state); + size_t limit = GPBCodedInputStreamPushLimit(state, length); + while (GPBCodedInputStreamBytesUntilLimit(state) > 0) { + int64_t val = GPBCodedInputStreamReadSInt64(state); + [array addValue:val]; + } + GPBCodedInputStreamPopLimit(state, limit); + } else { + int64_t val = GPBCodedInputStreamReadSInt64(state); + [array addValue:val]; + } + } else if (fieldType == GPBFieldTypeSingle) { + int64_t val = GPBCodedInputStreamReadSInt64(state); + GPBSetInt64IvarWithFieldInternal(context->result, field, val, + context->syntax); + } else { // fieldType == GPBFieldTypeMap + // The exact type doesn't matter, just need to know it is a GPB*Dictionary. + GPBInt32Int32Dictionary *map = + GetOrCreateMapIvarWithField(context->result, field, context->syntax); + [context->stream readMapEntry:map + extensionRegistry:nil + field:field + parentMessage:context->result]; + } + return NO; +} + +//%PDDM-EXPAND MERGE_FROM_CODED_INPUT_STREAM_POD_FUNC(UInt64, uint64_t, UInt64) +// This block of code is generated, do not edit it directly. + +static BOOL DynamicMergeFromCodedInputStreamUInt64(GPBFieldDescriptor *field, + void *voidContext) { + MergeFromCodedInputStreamContext *context = + (MergeFromCodedInputStreamContext *)voidContext; + GPBCodedInputStreamState *state = &context->stream->state_; + GPBFieldType fieldType = field.fieldType; + if (fieldType == GPBFieldTypeRepeated) { + GPBUInt64Array *array = + GetOrCreateArrayIvarWithField(context->result, field, context->syntax); + if (field.isPackable) { + int32_t length = GPBCodedInputStreamReadInt32(state); + size_t limit = GPBCodedInputStreamPushLimit(state, length); + while (GPBCodedInputStreamBytesUntilLimit(state) > 0) { + uint64_t val = GPBCodedInputStreamReadUInt64(state); + [array addValue:val]; + } + GPBCodedInputStreamPopLimit(state, limit); + } else { + uint64_t val = GPBCodedInputStreamReadUInt64(state); + [array addValue:val]; + } + } else if (fieldType == GPBFieldTypeSingle) { + uint64_t val = GPBCodedInputStreamReadUInt64(state); + GPBSetUInt64IvarWithFieldInternal(context->result, field, val, + context->syntax); + } else { // fieldType == GPBFieldTypeMap + // The exact type doesn't matter, just need to know it is a GPB*Dictionary. + GPBInt32Int32Dictionary *map = + GetOrCreateMapIvarWithField(context->result, field, context->syntax); + [context->stream readMapEntry:map + extensionRegistry:nil + field:field + parentMessage:context->result]; + } + return NO; +} + +//%PDDM-EXPAND MERGE_FROM_CODED_INPUT_STREAM_POD_FUNC(Fixed64, uint64_t, UInt64) +// This block of code is generated, do not edit it directly. + +static BOOL DynamicMergeFromCodedInputStreamFixed64(GPBFieldDescriptor *field, + void *voidContext) { + MergeFromCodedInputStreamContext *context = + (MergeFromCodedInputStreamContext *)voidContext; + GPBCodedInputStreamState *state = &context->stream->state_; + GPBFieldType fieldType = field.fieldType; + if (fieldType == GPBFieldTypeRepeated) { + GPBUInt64Array *array = + GetOrCreateArrayIvarWithField(context->result, field, context->syntax); + if (field.isPackable) { + int32_t length = GPBCodedInputStreamReadInt32(state); + size_t limit = GPBCodedInputStreamPushLimit(state, length); + while (GPBCodedInputStreamBytesUntilLimit(state) > 0) { + uint64_t val = GPBCodedInputStreamReadFixed64(state); + [array addValue:val]; + } + GPBCodedInputStreamPopLimit(state, limit); + } else { + uint64_t val = GPBCodedInputStreamReadFixed64(state); + [array addValue:val]; + } + } else if (fieldType == GPBFieldTypeSingle) { + uint64_t val = GPBCodedInputStreamReadFixed64(state); + GPBSetUInt64IvarWithFieldInternal(context->result, field, val, + context->syntax); + } else { // fieldType == GPBFieldTypeMap + // The exact type doesn't matter, just need to know it is a GPB*Dictionary. + GPBInt32Int32Dictionary *map = + GetOrCreateMapIvarWithField(context->result, field, context->syntax); + [context->stream readMapEntry:map + extensionRegistry:nil + field:field + parentMessage:context->result]; + } + return NO; +} + +//%PDDM-EXPAND MERGE_FROM_CODED_INPUT_STREAM_POD_FUNC(Float, float, Float) +// This block of code is generated, do not edit it directly. + +static BOOL DynamicMergeFromCodedInputStreamFloat(GPBFieldDescriptor *field, + void *voidContext) { + MergeFromCodedInputStreamContext *context = + (MergeFromCodedInputStreamContext *)voidContext; + GPBCodedInputStreamState *state = &context->stream->state_; + GPBFieldType fieldType = field.fieldType; + if (fieldType == GPBFieldTypeRepeated) { + GPBFloatArray *array = + GetOrCreateArrayIvarWithField(context->result, field, context->syntax); + if (field.isPackable) { + int32_t length = GPBCodedInputStreamReadInt32(state); + size_t limit = GPBCodedInputStreamPushLimit(state, length); + while (GPBCodedInputStreamBytesUntilLimit(state) > 0) { + float val = GPBCodedInputStreamReadFloat(state); + [array addValue:val]; + } + GPBCodedInputStreamPopLimit(state, limit); + } else { + float val = GPBCodedInputStreamReadFloat(state); + [array addValue:val]; + } + } else if (fieldType == GPBFieldTypeSingle) { + float val = GPBCodedInputStreamReadFloat(state); + GPBSetFloatIvarWithFieldInternal(context->result, field, val, + context->syntax); + } else { // fieldType == GPBFieldTypeMap + // The exact type doesn't matter, just need to know it is a GPB*Dictionary. + GPBInt32Int32Dictionary *map = + GetOrCreateMapIvarWithField(context->result, field, context->syntax); + [context->stream readMapEntry:map + extensionRegistry:nil + field:field + parentMessage:context->result]; + } + return NO; +} + +//%PDDM-EXPAND MERGE_FROM_CODED_INPUT_STREAM_POD_FUNC(Double, double, Double) +// This block of code is generated, do not edit it directly. + +static BOOL DynamicMergeFromCodedInputStreamDouble(GPBFieldDescriptor *field, + void *voidContext) { + MergeFromCodedInputStreamContext *context = + (MergeFromCodedInputStreamContext *)voidContext; + GPBCodedInputStreamState *state = &context->stream->state_; + GPBFieldType fieldType = field.fieldType; + if (fieldType == GPBFieldTypeRepeated) { + GPBDoubleArray *array = + GetOrCreateArrayIvarWithField(context->result, field, context->syntax); + if (field.isPackable) { + int32_t length = GPBCodedInputStreamReadInt32(state); + size_t limit = GPBCodedInputStreamPushLimit(state, length); + while (GPBCodedInputStreamBytesUntilLimit(state) > 0) { + double val = GPBCodedInputStreamReadDouble(state); + [array addValue:val]; + } + GPBCodedInputStreamPopLimit(state, limit); + } else { + double val = GPBCodedInputStreamReadDouble(state); + [array addValue:val]; + } + } else if (fieldType == GPBFieldTypeSingle) { + double val = GPBCodedInputStreamReadDouble(state); + GPBSetDoubleIvarWithFieldInternal(context->result, field, val, + context->syntax); + } else { // fieldType == GPBFieldTypeMap + // The exact type doesn't matter, just need to know it is a GPB*Dictionary. + GPBInt32Int32Dictionary *map = + GetOrCreateMapIvarWithField(context->result, field, context->syntax); + [context->stream readMapEntry:map + extensionRegistry:nil + field:field + parentMessage:context->result]; + } + return NO; +} + +//%PDDM-EXPAND MERGE_FROM_CODED_INPUT_STREAM_OBJ_FUNC(String) +// This block of code is generated, do not edit it directly. + +static BOOL DynamicMergeFromCodedInputStreamString(GPBFieldDescriptor *field, + void *voidContext) { + MergeFromCodedInputStreamContext *context = voidContext; + GPBCodedInputStreamState *state = &context->stream->state_; + GPBFieldType fieldType = field.fieldType; + if (fieldType == GPBFieldTypeMap) { + // GPB*Dictionary or NSDictionary, exact type doesn't matter at this point. + id map = + GetOrCreateMapIvarWithField(context->result, field, context->syntax); + [context->stream readMapEntry:map + extensionRegistry:nil + field:field + parentMessage:context->result]; + } else { + id val = GPBCodedInputStreamReadRetainedString(state); + if (fieldType == GPBFieldTypeRepeated) { + NSMutableArray *array = + GetOrCreateArrayIvarWithField(context->result, field, context->syntax); + [array addObject:val]; + [val release]; + } else { // fieldType == GPBFieldTypeSingle + GPBSetRetainedObjectIvarWithFieldInternal(context->result, field, val, + context->syntax); + } + } + return NO; +} + +//%PDDM-EXPAND MERGE_FROM_CODED_INPUT_STREAM_OBJ_FUNC(Data) +// This block of code is generated, do not edit it directly. + +static BOOL DynamicMergeFromCodedInputStreamData(GPBFieldDescriptor *field, + void *voidContext) { + MergeFromCodedInputStreamContext *context = voidContext; + GPBCodedInputStreamState *state = &context->stream->state_; + GPBFieldType fieldType = field.fieldType; + if (fieldType == GPBFieldTypeMap) { + // GPB*Dictionary or NSDictionary, exact type doesn't matter at this point. + id map = + GetOrCreateMapIvarWithField(context->result, field, context->syntax); + [context->stream readMapEntry:map + extensionRegistry:nil + field:field + parentMessage:context->result]; + } else { + id val = GPBCodedInputStreamReadRetainedData(state); + if (fieldType == GPBFieldTypeRepeated) { + NSMutableArray *array = + GetOrCreateArrayIvarWithField(context->result, field, context->syntax); + [array addObject:val]; + [val release]; + } else { // fieldType == GPBFieldTypeSingle + GPBSetRetainedObjectIvarWithFieldInternal(context->result, field, val, + context->syntax); + } + } + return NO; +} + +//%PDDM-EXPAND-END (15 expansions) + +- (void)mergeFromCodedInputStream:(GPBCodedInputStream *)input + extensionRegistry:(GPBExtensionRegistry *)extensionRegistry { + GPBDescriptor *descriptor = [self descriptor]; + GPBFileSyntax syntax = descriptor.file.syntax; + MergeFromCodedInputStreamContext context = { + self, input, self, extensionRegistry, 0, syntax + }; + GPBApplyStrictFunctions funcs = + GPBAPPLY_STRICT_FUNCTIONS_INIT(DynamicMergeFromCodedInputStream); + NSUInteger startingIndex = 0; + NSArray *fields = descriptor->fields_; + NSUInteger count = fields.count; + while (YES) { + BOOL merged = NO; + context.tag = GPBCodedInputStreamReadTag(&input->state_); + for (NSUInteger i = 0; i < count; ++i) { + if (startingIndex >= count) startingIndex = 0; + GPBFieldDescriptor *fieldDescriptor = fields[startingIndex]; + if (GPBFieldTag(fieldDescriptor) == context.tag) { + GPBApplyFunction function = funcs[GPBGetFieldType(fieldDescriptor)]; + function(fieldDescriptor, &context); + merged = YES; + break; + } else { + startingIndex += 1; + } + } + if (!merged) { + if (context.tag == 0) { + // zero signals EOF / limit reached + return; + } else { + if (GPBPreserveUnknownFields(syntax)) { + if (![self parseUnknownField:input + extensionRegistry:extensionRegistry + tag:context.tag]) { + // it's an endgroup tag + return; + } + } else { + if (![input skipField:context.tag]) { + return; + } + } + } + } + } +} + +#pragma mark - MergeFrom Support + +typedef struct MergeFromContext { + GPBMessage *other; + GPBMessage *result; + GPBFileSyntax syntax; +} MergeFromContext; + +//%PDDM-DEFINE GPB_MERGE_FROM_FUNC(NAME) +//%static BOOL MergeFrom##NAME(GPBFieldDescriptor *field, void *voidContext) { +//% MergeFromContext *context = (MergeFromContext *)voidContext; +//% BOOL otherHas = GPBGetHasIvarField(context->other, field); +//% if (otherHas) { +//% GPBSet##NAME##IvarWithFieldInternal( +//% context->result, field, GPBGet##NAME##IvarWithField(context->other, field), +//% context->syntax); +//% } +//% return YES; +//%} +//% +//%PDDM-EXPAND GPB_MERGE_FROM_FUNC(Bool) +// This block of code is generated, do not edit it directly. + +static BOOL MergeFromBool(GPBFieldDescriptor *field, void *voidContext) { + MergeFromContext *context = (MergeFromContext *)voidContext; + BOOL otherHas = GPBGetHasIvarField(context->other, field); + if (otherHas) { + GPBSetBoolIvarWithFieldInternal( + context->result, field, GPBGetBoolIvarWithField(context->other, field), + context->syntax); + } + return YES; +} + +//%PDDM-EXPAND GPB_MERGE_FROM_FUNC(Int32) +// This block of code is generated, do not edit it directly. + +static BOOL MergeFromInt32(GPBFieldDescriptor *field, void *voidContext) { + MergeFromContext *context = (MergeFromContext *)voidContext; + BOOL otherHas = GPBGetHasIvarField(context->other, field); + if (otherHas) { + GPBSetInt32IvarWithFieldInternal( + context->result, field, GPBGetInt32IvarWithField(context->other, field), + context->syntax); + } + return YES; +} + +//%PDDM-EXPAND GPB_MERGE_FROM_FUNC(UInt32) +// This block of code is generated, do not edit it directly. + +static BOOL MergeFromUInt32(GPBFieldDescriptor *field, void *voidContext) { + MergeFromContext *context = (MergeFromContext *)voidContext; + BOOL otherHas = GPBGetHasIvarField(context->other, field); + if (otherHas) { + GPBSetUInt32IvarWithFieldInternal( + context->result, field, GPBGetUInt32IvarWithField(context->other, field), + context->syntax); + } + return YES; +} + +//%PDDM-EXPAND GPB_MERGE_FROM_FUNC(Int64) +// This block of code is generated, do not edit it directly. + +static BOOL MergeFromInt64(GPBFieldDescriptor *field, void *voidContext) { + MergeFromContext *context = (MergeFromContext *)voidContext; + BOOL otherHas = GPBGetHasIvarField(context->other, field); + if (otherHas) { + GPBSetInt64IvarWithFieldInternal( + context->result, field, GPBGetInt64IvarWithField(context->other, field), + context->syntax); + } + return YES; +} + +//%PDDM-EXPAND GPB_MERGE_FROM_FUNC(UInt64) +// This block of code is generated, do not edit it directly. + +static BOOL MergeFromUInt64(GPBFieldDescriptor *field, void *voidContext) { + MergeFromContext *context = (MergeFromContext *)voidContext; + BOOL otherHas = GPBGetHasIvarField(context->other, field); + if (otherHas) { + GPBSetUInt64IvarWithFieldInternal( + context->result, field, GPBGetUInt64IvarWithField(context->other, field), + context->syntax); + } + return YES; +} + +//%PDDM-EXPAND GPB_MERGE_FROM_FUNC(Float) +// This block of code is generated, do not edit it directly. + +static BOOL MergeFromFloat(GPBFieldDescriptor *field, void *voidContext) { + MergeFromContext *context = (MergeFromContext *)voidContext; + BOOL otherHas = GPBGetHasIvarField(context->other, field); + if (otherHas) { + GPBSetFloatIvarWithFieldInternal( + context->result, field, GPBGetFloatIvarWithField(context->other, field), + context->syntax); + } + return YES; +} + +//%PDDM-EXPAND GPB_MERGE_FROM_FUNC(Double) +// This block of code is generated, do not edit it directly. + +static BOOL MergeFromDouble(GPBFieldDescriptor *field, void *voidContext) { + MergeFromContext *context = (MergeFromContext *)voidContext; + BOOL otherHas = GPBGetHasIvarField(context->other, field); + if (otherHas) { + GPBSetDoubleIvarWithFieldInternal( + context->result, field, GPBGetDoubleIvarWithField(context->other, field), + context->syntax); + } + return YES; +} + +//%PDDM-EXPAND-END (7 expansions) + +static BOOL MergeFromObject(GPBFieldDescriptor *field, void *voidContext) { + MergeFromContext *context = (MergeFromContext *)voidContext; + GPBFieldType fieldType = field.fieldType; + if (fieldType == GPBFieldTypeRepeated) { + // In the case of a list, they need to be appended, and there is no + // _hasIvar to worry about setting. + id otherArray = + GPBGetObjectIvarWithFieldNoAutocreate(context->other, field); + if (otherArray) { + GPBType fieldDataType = field->description_->type; + if (GPBTypeIsObject(fieldDataType)) { + NSMutableArray *resultArray = GetOrCreateArrayIvarWithField( + context->result, field, context->syntax); + [resultArray addObjectsFromArray:otherArray]; + } else if (fieldDataType == GPBTypeEnum) { + GPBEnumArray *resultArray = GetOrCreateArrayIvarWithField( + context->result, field, context->syntax); + [resultArray addRawValuesFromArray:otherArray]; + } else { + // The array type doesn't matter, that all implment + // -addValuesFromArray:. + GPBInt32Array *resultArray = GetOrCreateArrayIvarWithField( + context->result, field, context->syntax); + [resultArray addValuesFromArray:otherArray]; + } + } + return YES; + } + if (fieldType == GPBFieldTypeMap) { + // In the case of a map, they need to be merged, and there is no + // _hasIvar to worry about setting. + id otherDict = GPBGetObjectIvarWithFieldNoAutocreate(context->other, field); + if (otherDict) { + GPBType keyType = field.mapKeyType; + GPBType valueType = field->description_->type; + if (GPBTypeIsObject(keyType) && GPBTypeIsObject(valueType)) { + NSMutableDictionary *resultDict = GetOrCreateMapIvarWithField( + context->result, field, context->syntax); + [resultDict addEntriesFromDictionary:otherDict]; + } else if (valueType == GPBTypeEnum) { + // The exact type doesn't matter, just need to know it is a + // GPB*EnumDictionary. + GPBInt32EnumDictionary *resultDict = GetOrCreateMapIvarWithField( + context->result, field, context->syntax); + [resultDict addRawEntriesFromDictionary:otherDict]; + } else { + // The exact type doesn't matter, they all implement + // -addEntriesFromDictionary:. + GPBInt32Int32Dictionary *resultDict = GetOrCreateMapIvarWithField( + context->result, field, context->syntax); + [resultDict addEntriesFromDictionary:otherDict]; + } + } + return YES; + } + + int32_t hasIndex = GPBFieldHasIndex(field); + uint32_t fieldNumber = GPBFieldNumber(field); + BOOL otherHas = GPBGetHasIvar(context->other, hasIndex, fieldNumber); + if (!otherHas) { + return YES; + } + // GPBGetObjectIvarWithFieldNoAutocreate skips the has check, faster. + id otherVal = GPBGetObjectIvarWithFieldNoAutocreate(context->other, field); + if (GPBFieldTypeIsMessage(field)) { + if (GPBGetHasIvar(context->result, hasIndex, fieldNumber)) { + GPBMessage *message = + GPBGetObjectIvarWithFieldNoAutocreate(context->result, field); + [message mergeFrom:otherVal]; + } else { + GPBMessage *message = [otherVal copy]; + GPBSetRetainedObjectIvarWithFieldInternal(context->result, field, message, + context->syntax); + } + } else { + GPBSetObjectIvarWithFieldInternal(context->result, field, otherVal, + context->syntax); + } + return YES; +} + +- (void)mergeFrom:(GPBMessage *)other { + Class selfClass = [self class]; + Class otherClass = [other class]; + if (!([selfClass isSubclassOfClass:otherClass] || + [otherClass isSubclassOfClass:selfClass])) { + [NSException raise:NSInvalidArgumentException + format:@"Classes must match %@ != %@", selfClass, otherClass]; + } + + GPBApplyFunctions funcs = GPBAPPLY_FUNCTIONS_INIT(MergeFrom); + GPBFileSyntax syntax = [self descriptor].file.syntax; + MergeFromContext context = {other, self, syntax}; + GPBApplyFunctionsToMessageFields(&funcs, self, &context); + + // We assume someting got done, and become visible. + GPBBecomeVisibleToAutocreator(self); + + // Unknown fields. + if (!unknownFields_) { + [self setUnknownFields:context.other.unknownFields]; + } else { + [unknownFields_ mergeUnknownFields:context.other.unknownFields]; + } + + if (other->extensionMap_.count == 0) { + return; + } + + if (extensionMap_ == nil) { + extensionMap_ = + CloneExtensionMap(other->extensionMap_, NSZoneFromPointer(self)); + } else { + for (GPBExtensionField *thisField in other->extensionMap_) { + id otherValue = [other->extensionMap_ objectForKey:thisField]; + id value = [extensionMap_ objectForKey:thisField]; + GPBExtensionDescriptor *thisFieldDescriptor = thisField.descriptor; + BOOL isMessageExtension = GPBExtensionIsMessage(thisFieldDescriptor); + + if ([thisField isRepeated]) { + NSMutableArray *list = value; + if (list == nil) { + list = [[NSMutableArray alloc] init]; + [extensionMap_ setObject:list forKey:thisField]; + [list release]; + } + if (isMessageExtension) { + for (GPBMessage *otherListValue in otherValue) { + GPBMessage *copiedValue = [otherListValue copy]; + [list addObject:copiedValue]; + [copiedValue release]; + } + } else { + [list addObjectsFromArray:otherValue]; + } + } else { + if (isMessageExtension) { + if (value) { + [(GPBMessage *)value mergeFrom:(GPBMessage *)otherValue]; + } else { + GPBMessage *copiedValue = [otherValue copy]; + [extensionMap_ setObject:copiedValue forKey:thisField]; + [copiedValue release]; + } + } else { + [extensionMap_ setObject:otherValue forKey:thisField]; + } + } + + if (isMessageExtension && !thisFieldDescriptor.isRepeated) { + GPBMessage *autocreatedValue = + [[autocreatedExtensionMap_ objectForKey:thisField] retain]; + // Must remove from the map before calling GPBClearMessageAutocreator() + // so that GPBClearMessageAutocreator() knows its safe to clear. + [autocreatedExtensionMap_ removeObjectForKey:thisField]; + GPBClearMessageAutocreator(autocreatedValue); + [autocreatedValue release]; + } + } + } +} + +#pragma mark - IsEqual Support + +typedef struct IsEqualContext { + GPBMessage *other; + GPBMessage *self; + BOOL outIsEqual; +} IsEqualContext; + +// If both self and other "has" a value then compare. +//%PDDM-DEFINE IS_EQUAL_FUNC(NAME, TYPE) +//%static BOOL IsEqual##NAME(GPBFieldDescriptor *field, void *voidContext) { +//% IsEqualContext *context = (IsEqualContext *)voidContext; +//% int32_t hasIndex = GPBFieldHasIndex(field); +//% uint32_t fieldNum = GPBFieldNumber(field); +//% BOOL selfHas = GPBGetHasIvar(context->self, hasIndex, fieldNum); +//% BOOL otherHas = GPBGetHasIvar(context->other, hasIndex, fieldNum); +//% if (selfHas != otherHas) { +//% context->outIsEqual = NO; +//% return NO; +//% } +//% if (!selfHas) { +//% return YES; +//% } +//% TYPE selfVal = GPBGet##NAME##IvarWithField(context->self, field); +//% TYPE otherVal = GPBGet##NAME##IvarWithField(context->other, field); +//% if (selfVal != otherVal) { +//% context->outIsEqual = NO; +//% return NO; +//% } +//% return YES; +//%} +//% +//%PDDM-EXPAND IS_EQUAL_FUNC(Bool, BOOL) +// This block of code is generated, do not edit it directly. + +static BOOL IsEqualBool(GPBFieldDescriptor *field, void *voidContext) { + IsEqualContext *context = (IsEqualContext *)voidContext; + int32_t hasIndex = GPBFieldHasIndex(field); + uint32_t fieldNum = GPBFieldNumber(field); + BOOL selfHas = GPBGetHasIvar(context->self, hasIndex, fieldNum); + BOOL otherHas = GPBGetHasIvar(context->other, hasIndex, fieldNum); + if (selfHas != otherHas) { + context->outIsEqual = NO; + return NO; + } + if (!selfHas) { + return YES; + } + BOOL selfVal = GPBGetBoolIvarWithField(context->self, field); + BOOL otherVal = GPBGetBoolIvarWithField(context->other, field); + if (selfVal != otherVal) { + context->outIsEqual = NO; + return NO; + } + return YES; +} + +//%PDDM-EXPAND IS_EQUAL_FUNC(Int32, int32_t) +// This block of code is generated, do not edit it directly. + +static BOOL IsEqualInt32(GPBFieldDescriptor *field, void *voidContext) { + IsEqualContext *context = (IsEqualContext *)voidContext; + int32_t hasIndex = GPBFieldHasIndex(field); + uint32_t fieldNum = GPBFieldNumber(field); + BOOL selfHas = GPBGetHasIvar(context->self, hasIndex, fieldNum); + BOOL otherHas = GPBGetHasIvar(context->other, hasIndex, fieldNum); + if (selfHas != otherHas) { + context->outIsEqual = NO; + return NO; + } + if (!selfHas) { + return YES; + } + int32_t selfVal = GPBGetInt32IvarWithField(context->self, field); + int32_t otherVal = GPBGetInt32IvarWithField(context->other, field); + if (selfVal != otherVal) { + context->outIsEqual = NO; + return NO; + } + return YES; +} + +//%PDDM-EXPAND IS_EQUAL_FUNC(UInt32, uint32_t) +// This block of code is generated, do not edit it directly. + +static BOOL IsEqualUInt32(GPBFieldDescriptor *field, void *voidContext) { + IsEqualContext *context = (IsEqualContext *)voidContext; + int32_t hasIndex = GPBFieldHasIndex(field); + uint32_t fieldNum = GPBFieldNumber(field); + BOOL selfHas = GPBGetHasIvar(context->self, hasIndex, fieldNum); + BOOL otherHas = GPBGetHasIvar(context->other, hasIndex, fieldNum); + if (selfHas != otherHas) { + context->outIsEqual = NO; + return NO; + } + if (!selfHas) { + return YES; + } + uint32_t selfVal = GPBGetUInt32IvarWithField(context->self, field); + uint32_t otherVal = GPBGetUInt32IvarWithField(context->other, field); + if (selfVal != otherVal) { + context->outIsEqual = NO; + return NO; + } + return YES; +} + +//%PDDM-EXPAND IS_EQUAL_FUNC(Int64, int64_t) +// This block of code is generated, do not edit it directly. + +static BOOL IsEqualInt64(GPBFieldDescriptor *field, void *voidContext) { + IsEqualContext *context = (IsEqualContext *)voidContext; + int32_t hasIndex = GPBFieldHasIndex(field); + uint32_t fieldNum = GPBFieldNumber(field); + BOOL selfHas = GPBGetHasIvar(context->self, hasIndex, fieldNum); + BOOL otherHas = GPBGetHasIvar(context->other, hasIndex, fieldNum); + if (selfHas != otherHas) { + context->outIsEqual = NO; + return NO; + } + if (!selfHas) { + return YES; + } + int64_t selfVal = GPBGetInt64IvarWithField(context->self, field); + int64_t otherVal = GPBGetInt64IvarWithField(context->other, field); + if (selfVal != otherVal) { + context->outIsEqual = NO; + return NO; + } + return YES; +} + +//%PDDM-EXPAND IS_EQUAL_FUNC(UInt64, uint64_t) +// This block of code is generated, do not edit it directly. + +static BOOL IsEqualUInt64(GPBFieldDescriptor *field, void *voidContext) { + IsEqualContext *context = (IsEqualContext *)voidContext; + int32_t hasIndex = GPBFieldHasIndex(field); + uint32_t fieldNum = GPBFieldNumber(field); + BOOL selfHas = GPBGetHasIvar(context->self, hasIndex, fieldNum); + BOOL otherHas = GPBGetHasIvar(context->other, hasIndex, fieldNum); + if (selfHas != otherHas) { + context->outIsEqual = NO; + return NO; + } + if (!selfHas) { + return YES; + } + uint64_t selfVal = GPBGetUInt64IvarWithField(context->self, field); + uint64_t otherVal = GPBGetUInt64IvarWithField(context->other, field); + if (selfVal != otherVal) { + context->outIsEqual = NO; + return NO; + } + return YES; +} + +//%PDDM-EXPAND IS_EQUAL_FUNC(Float, float) +// This block of code is generated, do not edit it directly. + +static BOOL IsEqualFloat(GPBFieldDescriptor *field, void *voidContext) { + IsEqualContext *context = (IsEqualContext *)voidContext; + int32_t hasIndex = GPBFieldHasIndex(field); + uint32_t fieldNum = GPBFieldNumber(field); + BOOL selfHas = GPBGetHasIvar(context->self, hasIndex, fieldNum); + BOOL otherHas = GPBGetHasIvar(context->other, hasIndex, fieldNum); + if (selfHas != otherHas) { + context->outIsEqual = NO; + return NO; + } + if (!selfHas) { + return YES; + } + float selfVal = GPBGetFloatIvarWithField(context->self, field); + float otherVal = GPBGetFloatIvarWithField(context->other, field); + if (selfVal != otherVal) { + context->outIsEqual = NO; + return NO; + } + return YES; +} + +//%PDDM-EXPAND IS_EQUAL_FUNC(Double, double) +// This block of code is generated, do not edit it directly. + +static BOOL IsEqualDouble(GPBFieldDescriptor *field, void *voidContext) { + IsEqualContext *context = (IsEqualContext *)voidContext; + int32_t hasIndex = GPBFieldHasIndex(field); + uint32_t fieldNum = GPBFieldNumber(field); + BOOL selfHas = GPBGetHasIvar(context->self, hasIndex, fieldNum); + BOOL otherHas = GPBGetHasIvar(context->other, hasIndex, fieldNum); + if (selfHas != otherHas) { + context->outIsEqual = NO; + return NO; + } + if (!selfHas) { + return YES; + } + double selfVal = GPBGetDoubleIvarWithField(context->self, field); + double otherVal = GPBGetDoubleIvarWithField(context->other, field); + if (selfVal != otherVal) { + context->outIsEqual = NO; + return NO; + } + return YES; +} + +//%PDDM-EXPAND-END (7 expansions) + +static BOOL IsEqualObject(GPBFieldDescriptor *field, void *voidContext) { + IsEqualContext *context = (IsEqualContext *)voidContext; + if (GPBFieldIsMapOrArray(field)) { + // In the case of a list/map, there is no _hasIvar to worry about checking. + // NOTE: These are NSArray/GPB*Array/NSDictionary/GPB*Dictionary, but the + // type doesn't really matter as the object just has to support + // -count/-isEqual:. + NSArray *resultMapOrArray = + GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + NSArray *otherMapOrArray = + GPBGetObjectIvarWithFieldNoAutocreate(context->other, field); + context->outIsEqual = + (resultMapOrArray.count == 0 && otherMapOrArray.count == 0) || + [resultMapOrArray isEqual:otherMapOrArray]; + return context->outIsEqual; + } + int32_t hasIndex = GPBFieldHasIndex(field); + uint32_t fieldNum = GPBFieldNumber(field); + BOOL selfHas = GPBGetHasIvar(context->self, hasIndex, fieldNum); + BOOL otherHas = GPBGetHasIvar(context->other, hasIndex, fieldNum); + if (selfHas != otherHas) { + context->outIsEqual = NO; + return NO; + } + if (!selfHas) { + return YES; + } + // GPBGetObjectIvarWithFieldNoAutocreate skips the has check, faster. + NSObject *selfVal = + GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + NSObject *otherVal = + GPBGetObjectIvarWithFieldNoAutocreate(context->other, field); + + // This covers case where selfVal is set to nil, as well as shortcuts the call + // to isEqual: in common cases. + if (selfVal == otherVal) { + return YES; + } + if (![selfVal isEqual:otherVal]) { + context->outIsEqual = NO; + return NO; + } + return YES; +} + +- (BOOL)isEqual:(GPBMessage *)other { + if (other == self) { + return YES; + } + if (![other isKindOfClass:[self class]] && + ![self isKindOfClass:[other class]]) { + return NO; + } + GPBApplyFunctions funcs = GPBAPPLY_FUNCTIONS_INIT(IsEqual); + IsEqualContext context = {other, self, YES}; + GPBApplyFunctionsToMessageFields(&funcs, self, &context); + if (!context.outIsEqual) { + return NO; + } + + // nil and empty are equal + if (extensionMap_.count != 0 || other->extensionMap_.count != 0) { + if (![extensionMap_ isEqual:other->extensionMap_]) { + return NO; + } + } + + // nil and empty are equal + GPBUnknownFieldSet *otherUnknowns = other.unknownFields; + if ([unknownFields_ countOfFields] != 0 || + [otherUnknowns countOfFields] != 0) { + if (![unknownFields_ isEqual:otherUnknowns]) { + return NO; + } + } + return YES; +} + +// It is very difficult to implement a generic hash for ProtoBuf messages that +// will perform well. If you need hashing on your ProtoBufs (eg you are using +// them as dictionary keys) you will probably want to implement a ProtoBuf +// message specific hash as a category on your protobuf class. Do not make it a +// category on GPBMessage as you will conflict with this hash, and will possibly +// override hash for all generated protobufs. A good implementation of hash will +// be really fast, so we would recommend only hashing protobufs that have an +// identifier field of some kind that you can easily hash. If you implement +// hash, we would strongly recommend overriding isEqual: in your category as +// well, as the default implementation of isEqual: is extremely slow, and may +// drastically affect performance in large sets. +- (NSUInteger)hash { + GPBDescriptor *descriptor = [[self class] descriptor]; + const NSUInteger prime = 19; + + // Start with the descriptor and then mix it with the field numbers that + // are set. Hopefully that will give a spread based on classes and what + // fields are set. + NSUInteger result = (NSUInteger)descriptor; + for (GPBFieldDescriptor *field in descriptor->fields_) { + if (GPBFieldIsMapOrArray(field)) { + // Exact type doesn't matter, just check if there are any elements. + NSArray *mapOrArray = GPBGetObjectIvarWithFieldNoAutocreate(self, field); + if (mapOrArray.count) { + result = prime * result + GPBFieldNumber(field); + } + } else if (GPBGetHasIvarField(self, field)) { + result = prime * result + GPBFieldNumber(field); + } + } + return result; +} + +#pragma mark - Description Support + +- (NSString *)description { + NSString *textFormat = GPBTextFormatForMessage(self, @" "); + NSString *description = [NSString + stringWithFormat:@"<%@ %p>: {\n%@}", [self class], self, textFormat]; + return description; +} + +#if DEBUG + +// Xcode 5.1 added support for custom quick look info. +// https://developer.apple.com/library/ios/documentation/IDEs/Conceptual/CustomClassDisplay_in_QuickLook/CH01-quick_look_for_custom_objects/CH01-quick_look_for_custom_objects.html#//apple_ref/doc/uid/TP40014001-CH2-SW1 +- (id)debugQuickLookObject { + return GPBTextFormatForMessage(self, nil); +} + +#endif // DEBUG + +#pragma mark - SerializedSize Support + +// Serialized size is only calculated once, and then is stored into +// memoizedSerializedSize. + +typedef struct SerializedSizeContext { + GPBMessage *self; + size_t outSize; +} SerializedSizeContext; + +//%PDDM-DEFINE SERIALIZED_SIZE_POD_FUNC(NAME, TYPE, REAL_TYPE) +//%SERIALIZED_SIZE_POD_FUNC_FULL(NAME, TYPE, REAL_TYPE, REAL_TYPE, ) +//%PDDM-DEFINE SERIALIZED_SIZE_POD_FUNC_FULL(NAME, TYPE, REAL_TYPE, ARRAY_TYPE, ARRAY_ACCESSOR_NAME) +//%static BOOL DynamicSerializedSize##NAME(GPBFieldDescriptor *field, +//% NAME$S void *voidContext) { +//% SerializedSizeContext *context = (SerializedSizeContext *)voidContext; +//% GPBFieldType fieldType = field.fieldType; +//% if (fieldType == GPBFieldTypeRepeated) { +//% GPB##ARRAY_TYPE##Array *array = +//% GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); +//% NSUInteger count = array.count; +//% if (count == 0) return YES; +//% __block size_t dataSize = 0; +//% [array enumerate##ARRAY_ACCESSOR_NAME##ValuesWithBlock:^(TYPE value, NSUInteger idx, BOOL *stop) { +//% #pragma unused(idx, stop) +//% dataSize += GPBCompute##NAME##SizeNoTag(value); +//% }]; +//% context->outSize += dataSize; +//% size_t tagSize = GPBComputeTagSize(GPBFieldNumber(field)); +//% if (field.isPackable) { +//% context->outSize += tagSize; +//% context->outSize += GPBComputeSizeTSizeAsInt32NoTag(dataSize); +//% } else { +//% context->outSize += count * tagSize; +//% } +//% } else if (fieldType == GPBFieldTypeSingle) { +//% BOOL selfHas = GPBGetHasIvarField(context->self, field); +//% if (selfHas) { +//% TYPE selfVal = GPBGet##REAL_TYPE##IvarWithField(context->self, field); +//% context->outSize += GPBCompute##NAME##Size(GPBFieldNumber(field), selfVal); +//% } +//% } else { // fieldType == GPBFieldTypeMap +//% // Type will be GPB*##REAL_TYPE##Dictionary, exact type doesn't matter. +//% GPBInt32##REAL_TYPE##Dictionary *map = +//% GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); +//% context->outSize += [map computeSerializedSizeAsField:field]; +//% } +//% return YES; +//%} +//% +//%PDDM-DEFINE SERIALIZED_SIZE_OBJECT_FUNC(NAME) +//%static BOOL DynamicSerializedSize##NAME(GPBFieldDescriptor *field, +//% NAME$S void *voidContext) { +//% SerializedSizeContext *context = (SerializedSizeContext *)voidContext; +//% GPBFieldType fieldType = field.fieldType; +//% if (fieldType == GPBFieldTypeRepeated) { +//% NSArray *array = +//% GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); +//% for (id value in array) { +//% context->outSize += GPBCompute##NAME##SizeNoTag(value); +//% } +//% size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), +//% GPBGetFieldType(field)); +//% context->outSize += array.count * tagSize; +//% } else if (fieldType == GPBFieldTypeSingle) { +//% BOOL selfHas = GPBGetHasIvarField(context->self, field); +//% if (selfHas) { +//% // GPBGetObjectIvarWithFieldNoAutocreate() avoids doing the has check +//% // again. +//% id selfVal = GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); +//% context->outSize += GPBCompute##NAME##Size(GPBFieldNumber(field), selfVal); +//% } +//% } else { // fieldType == GPBFieldTypeMap +//% GPBType mapKeyType = field.mapKeyType; +//% if (mapKeyType == GPBTypeString) { +//% // If key type was string, then the map is an NSDictionary. +//% NSDictionary *map = +//% GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); +//% context->outSize += GPBDictionaryComputeSizeInternalHelper(map, field); +//% } else { +//% // Type will be GPB*##NAME##Dictionary, exact type doesn't matter. +//% GPBInt32ObjectDictionary *map = +//% GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); +//% context->outSize += [map computeSerializedSizeAsField:field]; +//% } +//% } +//% return YES; +//%} +//% +//%PDDM-EXPAND SERIALIZED_SIZE_POD_FUNC(Bool, BOOL, Bool) +// This block of code is generated, do not edit it directly. + +static BOOL DynamicSerializedSizeBool(GPBFieldDescriptor *field, + void *voidContext) { + SerializedSizeContext *context = (SerializedSizeContext *)voidContext; + GPBFieldType fieldType = field.fieldType; + if (fieldType == GPBFieldTypeRepeated) { + GPBBoolArray *array = + GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + NSUInteger count = array.count; + if (count == 0) return YES; + __block size_t dataSize = 0; + [array enumerateValuesWithBlock:^(BOOL value, NSUInteger idx, BOOL *stop) { + #pragma unused(idx, stop) + dataSize += GPBComputeBoolSizeNoTag(value); + }]; + context->outSize += dataSize; + size_t tagSize = GPBComputeTagSize(GPBFieldNumber(field)); + if (field.isPackable) { + context->outSize += tagSize; + context->outSize += GPBComputeSizeTSizeAsInt32NoTag(dataSize); + } else { + context->outSize += count * tagSize; + } + } else if (fieldType == GPBFieldTypeSingle) { + BOOL selfHas = GPBGetHasIvarField(context->self, field); + if (selfHas) { + BOOL selfVal = GPBGetBoolIvarWithField(context->self, field); + context->outSize += GPBComputeBoolSize(GPBFieldNumber(field), selfVal); + } + } else { // fieldType == GPBFieldTypeMap + // Type will be GPB*BoolDictionary, exact type doesn't matter. + GPBInt32BoolDictionary *map = + GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + context->outSize += [map computeSerializedSizeAsField:field]; + } + return YES; +} + +//%PDDM-EXPAND SERIALIZED_SIZE_POD_FUNC(Int32, int32_t, Int32) +// This block of code is generated, do not edit it directly. + +static BOOL DynamicSerializedSizeInt32(GPBFieldDescriptor *field, + void *voidContext) { + SerializedSizeContext *context = (SerializedSizeContext *)voidContext; + GPBFieldType fieldType = field.fieldType; + if (fieldType == GPBFieldTypeRepeated) { + GPBInt32Array *array = + GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + NSUInteger count = array.count; + if (count == 0) return YES; + __block size_t dataSize = 0; + [array enumerateValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) { + #pragma unused(idx, stop) + dataSize += GPBComputeInt32SizeNoTag(value); + }]; + context->outSize += dataSize; + size_t tagSize = GPBComputeTagSize(GPBFieldNumber(field)); + if (field.isPackable) { + context->outSize += tagSize; + context->outSize += GPBComputeSizeTSizeAsInt32NoTag(dataSize); + } else { + context->outSize += count * tagSize; + } + } else if (fieldType == GPBFieldTypeSingle) { + BOOL selfHas = GPBGetHasIvarField(context->self, field); + if (selfHas) { + int32_t selfVal = GPBGetInt32IvarWithField(context->self, field); + context->outSize += GPBComputeInt32Size(GPBFieldNumber(field), selfVal); + } + } else { // fieldType == GPBFieldTypeMap + // Type will be GPB*Int32Dictionary, exact type doesn't matter. + GPBInt32Int32Dictionary *map = + GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + context->outSize += [map computeSerializedSizeAsField:field]; + } + return YES; +} + +//%PDDM-EXPAND SERIALIZED_SIZE_POD_FUNC(SInt32, int32_t, Int32) +// This block of code is generated, do not edit it directly. + +static BOOL DynamicSerializedSizeSInt32(GPBFieldDescriptor *field, + void *voidContext) { + SerializedSizeContext *context = (SerializedSizeContext *)voidContext; + GPBFieldType fieldType = field.fieldType; + if (fieldType == GPBFieldTypeRepeated) { + GPBInt32Array *array = + GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + NSUInteger count = array.count; + if (count == 0) return YES; + __block size_t dataSize = 0; + [array enumerateValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) { + #pragma unused(idx, stop) + dataSize += GPBComputeSInt32SizeNoTag(value); + }]; + context->outSize += dataSize; + size_t tagSize = GPBComputeTagSize(GPBFieldNumber(field)); + if (field.isPackable) { + context->outSize += tagSize; + context->outSize += GPBComputeSizeTSizeAsInt32NoTag(dataSize); + } else { + context->outSize += count * tagSize; + } + } else if (fieldType == GPBFieldTypeSingle) { + BOOL selfHas = GPBGetHasIvarField(context->self, field); + if (selfHas) { + int32_t selfVal = GPBGetInt32IvarWithField(context->self, field); + context->outSize += GPBComputeSInt32Size(GPBFieldNumber(field), selfVal); + } + } else { // fieldType == GPBFieldTypeMap + // Type will be GPB*Int32Dictionary, exact type doesn't matter. + GPBInt32Int32Dictionary *map = + GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + context->outSize += [map computeSerializedSizeAsField:field]; + } + return YES; +} + +//%PDDM-EXPAND SERIALIZED_SIZE_POD_FUNC(SFixed32, int32_t, Int32) +// This block of code is generated, do not edit it directly. + +static BOOL DynamicSerializedSizeSFixed32(GPBFieldDescriptor *field, + void *voidContext) { + SerializedSizeContext *context = (SerializedSizeContext *)voidContext; + GPBFieldType fieldType = field.fieldType; + if (fieldType == GPBFieldTypeRepeated) { + GPBInt32Array *array = + GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + NSUInteger count = array.count; + if (count == 0) return YES; + __block size_t dataSize = 0; + [array enumerateValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) { + #pragma unused(idx, stop) + dataSize += GPBComputeSFixed32SizeNoTag(value); + }]; + context->outSize += dataSize; + size_t tagSize = GPBComputeTagSize(GPBFieldNumber(field)); + if (field.isPackable) { + context->outSize += tagSize; + context->outSize += GPBComputeSizeTSizeAsInt32NoTag(dataSize); + } else { + context->outSize += count * tagSize; + } + } else if (fieldType == GPBFieldTypeSingle) { + BOOL selfHas = GPBGetHasIvarField(context->self, field); + if (selfHas) { + int32_t selfVal = GPBGetInt32IvarWithField(context->self, field); + context->outSize += GPBComputeSFixed32Size(GPBFieldNumber(field), selfVal); + } + } else { // fieldType == GPBFieldTypeMap + // Type will be GPB*Int32Dictionary, exact type doesn't matter. + GPBInt32Int32Dictionary *map = + GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + context->outSize += [map computeSerializedSizeAsField:field]; + } + return YES; +} + +//%PDDM-EXPAND SERIALIZED_SIZE_POD_FUNC_FULL(Enum, int32_t, Int32, Enum, Raw) +// This block of code is generated, do not edit it directly. + +static BOOL DynamicSerializedSizeEnum(GPBFieldDescriptor *field, + void *voidContext) { + SerializedSizeContext *context = (SerializedSizeContext *)voidContext; + GPBFieldType fieldType = field.fieldType; + if (fieldType == GPBFieldTypeRepeated) { + GPBEnumArray *array = + GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + NSUInteger count = array.count; + if (count == 0) return YES; + __block size_t dataSize = 0; + [array enumerateRawValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) { + #pragma unused(idx, stop) + dataSize += GPBComputeEnumSizeNoTag(value); + }]; + context->outSize += dataSize; + size_t tagSize = GPBComputeTagSize(GPBFieldNumber(field)); + if (field.isPackable) { + context->outSize += tagSize; + context->outSize += GPBComputeSizeTSizeAsInt32NoTag(dataSize); + } else { + context->outSize += count * tagSize; + } + } else if (fieldType == GPBFieldTypeSingle) { + BOOL selfHas = GPBGetHasIvarField(context->self, field); + if (selfHas) { + int32_t selfVal = GPBGetInt32IvarWithField(context->self, field); + context->outSize += GPBComputeEnumSize(GPBFieldNumber(field), selfVal); + } + } else { // fieldType == GPBFieldTypeMap + // Type will be GPB*Int32Dictionary, exact type doesn't matter. + GPBInt32Int32Dictionary *map = + GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + context->outSize += [map computeSerializedSizeAsField:field]; + } + return YES; +} + +//%PDDM-EXPAND SERIALIZED_SIZE_POD_FUNC(UInt32, uint32_t, UInt32) +// This block of code is generated, do not edit it directly. + +static BOOL DynamicSerializedSizeUInt32(GPBFieldDescriptor *field, + void *voidContext) { + SerializedSizeContext *context = (SerializedSizeContext *)voidContext; + GPBFieldType fieldType = field.fieldType; + if (fieldType == GPBFieldTypeRepeated) { + GPBUInt32Array *array = + GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + NSUInteger count = array.count; + if (count == 0) return YES; + __block size_t dataSize = 0; + [array enumerateValuesWithBlock:^(uint32_t value, NSUInteger idx, BOOL *stop) { + #pragma unused(idx, stop) + dataSize += GPBComputeUInt32SizeNoTag(value); + }]; + context->outSize += dataSize; + size_t tagSize = GPBComputeTagSize(GPBFieldNumber(field)); + if (field.isPackable) { + context->outSize += tagSize; + context->outSize += GPBComputeSizeTSizeAsInt32NoTag(dataSize); + } else { + context->outSize += count * tagSize; + } + } else if (fieldType == GPBFieldTypeSingle) { + BOOL selfHas = GPBGetHasIvarField(context->self, field); + if (selfHas) { + uint32_t selfVal = GPBGetUInt32IvarWithField(context->self, field); + context->outSize += GPBComputeUInt32Size(GPBFieldNumber(field), selfVal); + } + } else { // fieldType == GPBFieldTypeMap + // Type will be GPB*UInt32Dictionary, exact type doesn't matter. + GPBInt32UInt32Dictionary *map = + GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + context->outSize += [map computeSerializedSizeAsField:field]; + } + return YES; +} + +//%PDDM-EXPAND SERIALIZED_SIZE_POD_FUNC(Fixed32, uint32_t, UInt32) +// This block of code is generated, do not edit it directly. + +static BOOL DynamicSerializedSizeFixed32(GPBFieldDescriptor *field, + void *voidContext) { + SerializedSizeContext *context = (SerializedSizeContext *)voidContext; + GPBFieldType fieldType = field.fieldType; + if (fieldType == GPBFieldTypeRepeated) { + GPBUInt32Array *array = + GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + NSUInteger count = array.count; + if (count == 0) return YES; + __block size_t dataSize = 0; + [array enumerateValuesWithBlock:^(uint32_t value, NSUInteger idx, BOOL *stop) { + #pragma unused(idx, stop) + dataSize += GPBComputeFixed32SizeNoTag(value); + }]; + context->outSize += dataSize; + size_t tagSize = GPBComputeTagSize(GPBFieldNumber(field)); + if (field.isPackable) { + context->outSize += tagSize; + context->outSize += GPBComputeSizeTSizeAsInt32NoTag(dataSize); + } else { + context->outSize += count * tagSize; + } + } else if (fieldType == GPBFieldTypeSingle) { + BOOL selfHas = GPBGetHasIvarField(context->self, field); + if (selfHas) { + uint32_t selfVal = GPBGetUInt32IvarWithField(context->self, field); + context->outSize += GPBComputeFixed32Size(GPBFieldNumber(field), selfVal); + } + } else { // fieldType == GPBFieldTypeMap + // Type will be GPB*UInt32Dictionary, exact type doesn't matter. + GPBInt32UInt32Dictionary *map = + GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + context->outSize += [map computeSerializedSizeAsField:field]; + } + return YES; +} + +//%PDDM-EXPAND SERIALIZED_SIZE_POD_FUNC(Int64, int64_t, Int64) +// This block of code is generated, do not edit it directly. + +static BOOL DynamicSerializedSizeInt64(GPBFieldDescriptor *field, + void *voidContext) { + SerializedSizeContext *context = (SerializedSizeContext *)voidContext; + GPBFieldType fieldType = field.fieldType; + if (fieldType == GPBFieldTypeRepeated) { + GPBInt64Array *array = + GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + NSUInteger count = array.count; + if (count == 0) return YES; + __block size_t dataSize = 0; + [array enumerateValuesWithBlock:^(int64_t value, NSUInteger idx, BOOL *stop) { + #pragma unused(idx, stop) + dataSize += GPBComputeInt64SizeNoTag(value); + }]; + context->outSize += dataSize; + size_t tagSize = GPBComputeTagSize(GPBFieldNumber(field)); + if (field.isPackable) { + context->outSize += tagSize; + context->outSize += GPBComputeSizeTSizeAsInt32NoTag(dataSize); + } else { + context->outSize += count * tagSize; + } + } else if (fieldType == GPBFieldTypeSingle) { + BOOL selfHas = GPBGetHasIvarField(context->self, field); + if (selfHas) { + int64_t selfVal = GPBGetInt64IvarWithField(context->self, field); + context->outSize += GPBComputeInt64Size(GPBFieldNumber(field), selfVal); + } + } else { // fieldType == GPBFieldTypeMap + // Type will be GPB*Int64Dictionary, exact type doesn't matter. + GPBInt32Int64Dictionary *map = + GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + context->outSize += [map computeSerializedSizeAsField:field]; + } + return YES; +} + +//%PDDM-EXPAND SERIALIZED_SIZE_POD_FUNC(SFixed64, int64_t, Int64) +// This block of code is generated, do not edit it directly. + +static BOOL DynamicSerializedSizeSFixed64(GPBFieldDescriptor *field, + void *voidContext) { + SerializedSizeContext *context = (SerializedSizeContext *)voidContext; + GPBFieldType fieldType = field.fieldType; + if (fieldType == GPBFieldTypeRepeated) { + GPBInt64Array *array = + GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + NSUInteger count = array.count; + if (count == 0) return YES; + __block size_t dataSize = 0; + [array enumerateValuesWithBlock:^(int64_t value, NSUInteger idx, BOOL *stop) { + #pragma unused(idx, stop) + dataSize += GPBComputeSFixed64SizeNoTag(value); + }]; + context->outSize += dataSize; + size_t tagSize = GPBComputeTagSize(GPBFieldNumber(field)); + if (field.isPackable) { + context->outSize += tagSize; + context->outSize += GPBComputeSizeTSizeAsInt32NoTag(dataSize); + } else { + context->outSize += count * tagSize; + } + } else if (fieldType == GPBFieldTypeSingle) { + BOOL selfHas = GPBGetHasIvarField(context->self, field); + if (selfHas) { + int64_t selfVal = GPBGetInt64IvarWithField(context->self, field); + context->outSize += GPBComputeSFixed64Size(GPBFieldNumber(field), selfVal); + } + } else { // fieldType == GPBFieldTypeMap + // Type will be GPB*Int64Dictionary, exact type doesn't matter. + GPBInt32Int64Dictionary *map = + GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + context->outSize += [map computeSerializedSizeAsField:field]; + } + return YES; +} + +//%PDDM-EXPAND SERIALIZED_SIZE_POD_FUNC(SInt64, int64_t, Int64) +// This block of code is generated, do not edit it directly. + +static BOOL DynamicSerializedSizeSInt64(GPBFieldDescriptor *field, + void *voidContext) { + SerializedSizeContext *context = (SerializedSizeContext *)voidContext; + GPBFieldType fieldType = field.fieldType; + if (fieldType == GPBFieldTypeRepeated) { + GPBInt64Array *array = + GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + NSUInteger count = array.count; + if (count == 0) return YES; + __block size_t dataSize = 0; + [array enumerateValuesWithBlock:^(int64_t value, NSUInteger idx, BOOL *stop) { + #pragma unused(idx, stop) + dataSize += GPBComputeSInt64SizeNoTag(value); + }]; + context->outSize += dataSize; + size_t tagSize = GPBComputeTagSize(GPBFieldNumber(field)); + if (field.isPackable) { + context->outSize += tagSize; + context->outSize += GPBComputeSizeTSizeAsInt32NoTag(dataSize); + } else { + context->outSize += count * tagSize; + } + } else if (fieldType == GPBFieldTypeSingle) { + BOOL selfHas = GPBGetHasIvarField(context->self, field); + if (selfHas) { + int64_t selfVal = GPBGetInt64IvarWithField(context->self, field); + context->outSize += GPBComputeSInt64Size(GPBFieldNumber(field), selfVal); + } + } else { // fieldType == GPBFieldTypeMap + // Type will be GPB*Int64Dictionary, exact type doesn't matter. + GPBInt32Int64Dictionary *map = + GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + context->outSize += [map computeSerializedSizeAsField:field]; + } + return YES; +} + +//%PDDM-EXPAND SERIALIZED_SIZE_POD_FUNC(UInt64, uint64_t, UInt64) +// This block of code is generated, do not edit it directly. + +static BOOL DynamicSerializedSizeUInt64(GPBFieldDescriptor *field, + void *voidContext) { + SerializedSizeContext *context = (SerializedSizeContext *)voidContext; + GPBFieldType fieldType = field.fieldType; + if (fieldType == GPBFieldTypeRepeated) { + GPBUInt64Array *array = + GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + NSUInteger count = array.count; + if (count == 0) return YES; + __block size_t dataSize = 0; + [array enumerateValuesWithBlock:^(uint64_t value, NSUInteger idx, BOOL *stop) { + #pragma unused(idx, stop) + dataSize += GPBComputeUInt64SizeNoTag(value); + }]; + context->outSize += dataSize; + size_t tagSize = GPBComputeTagSize(GPBFieldNumber(field)); + if (field.isPackable) { + context->outSize += tagSize; + context->outSize += GPBComputeSizeTSizeAsInt32NoTag(dataSize); + } else { + context->outSize += count * tagSize; + } + } else if (fieldType == GPBFieldTypeSingle) { + BOOL selfHas = GPBGetHasIvarField(context->self, field); + if (selfHas) { + uint64_t selfVal = GPBGetUInt64IvarWithField(context->self, field); + context->outSize += GPBComputeUInt64Size(GPBFieldNumber(field), selfVal); + } + } else { // fieldType == GPBFieldTypeMap + // Type will be GPB*UInt64Dictionary, exact type doesn't matter. + GPBInt32UInt64Dictionary *map = + GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + context->outSize += [map computeSerializedSizeAsField:field]; + } + return YES; +} + +//%PDDM-EXPAND SERIALIZED_SIZE_POD_FUNC(Fixed64, uint64_t, UInt64) +// This block of code is generated, do not edit it directly. + +static BOOL DynamicSerializedSizeFixed64(GPBFieldDescriptor *field, + void *voidContext) { + SerializedSizeContext *context = (SerializedSizeContext *)voidContext; + GPBFieldType fieldType = field.fieldType; + if (fieldType == GPBFieldTypeRepeated) { + GPBUInt64Array *array = + GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + NSUInteger count = array.count; + if (count == 0) return YES; + __block size_t dataSize = 0; + [array enumerateValuesWithBlock:^(uint64_t value, NSUInteger idx, BOOL *stop) { + #pragma unused(idx, stop) + dataSize += GPBComputeFixed64SizeNoTag(value); + }]; + context->outSize += dataSize; + size_t tagSize = GPBComputeTagSize(GPBFieldNumber(field)); + if (field.isPackable) { + context->outSize += tagSize; + context->outSize += GPBComputeSizeTSizeAsInt32NoTag(dataSize); + } else { + context->outSize += count * tagSize; + } + } else if (fieldType == GPBFieldTypeSingle) { + BOOL selfHas = GPBGetHasIvarField(context->self, field); + if (selfHas) { + uint64_t selfVal = GPBGetUInt64IvarWithField(context->self, field); + context->outSize += GPBComputeFixed64Size(GPBFieldNumber(field), selfVal); + } + } else { // fieldType == GPBFieldTypeMap + // Type will be GPB*UInt64Dictionary, exact type doesn't matter. + GPBInt32UInt64Dictionary *map = + GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + context->outSize += [map computeSerializedSizeAsField:field]; + } + return YES; +} + +//%PDDM-EXPAND SERIALIZED_SIZE_POD_FUNC(Float, float, Float) +// This block of code is generated, do not edit it directly. + +static BOOL DynamicSerializedSizeFloat(GPBFieldDescriptor *field, + void *voidContext) { + SerializedSizeContext *context = (SerializedSizeContext *)voidContext; + GPBFieldType fieldType = field.fieldType; + if (fieldType == GPBFieldTypeRepeated) { + GPBFloatArray *array = + GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + NSUInteger count = array.count; + if (count == 0) return YES; + __block size_t dataSize = 0; + [array enumerateValuesWithBlock:^(float value, NSUInteger idx, BOOL *stop) { + #pragma unused(idx, stop) + dataSize += GPBComputeFloatSizeNoTag(value); + }]; + context->outSize += dataSize; + size_t tagSize = GPBComputeTagSize(GPBFieldNumber(field)); + if (field.isPackable) { + context->outSize += tagSize; + context->outSize += GPBComputeSizeTSizeAsInt32NoTag(dataSize); + } else { + context->outSize += count * tagSize; + } + } else if (fieldType == GPBFieldTypeSingle) { + BOOL selfHas = GPBGetHasIvarField(context->self, field); + if (selfHas) { + float selfVal = GPBGetFloatIvarWithField(context->self, field); + context->outSize += GPBComputeFloatSize(GPBFieldNumber(field), selfVal); + } + } else { // fieldType == GPBFieldTypeMap + // Type will be GPB*FloatDictionary, exact type doesn't matter. + GPBInt32FloatDictionary *map = + GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + context->outSize += [map computeSerializedSizeAsField:field]; + } + return YES; +} + +//%PDDM-EXPAND SERIALIZED_SIZE_POD_FUNC(Double, double, Double) +// This block of code is generated, do not edit it directly. + +static BOOL DynamicSerializedSizeDouble(GPBFieldDescriptor *field, + void *voidContext) { + SerializedSizeContext *context = (SerializedSizeContext *)voidContext; + GPBFieldType fieldType = field.fieldType; + if (fieldType == GPBFieldTypeRepeated) { + GPBDoubleArray *array = + GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + NSUInteger count = array.count; + if (count == 0) return YES; + __block size_t dataSize = 0; + [array enumerateValuesWithBlock:^(double value, NSUInteger idx, BOOL *stop) { + #pragma unused(idx, stop) + dataSize += GPBComputeDoubleSizeNoTag(value); + }]; + context->outSize += dataSize; + size_t tagSize = GPBComputeTagSize(GPBFieldNumber(field)); + if (field.isPackable) { + context->outSize += tagSize; + context->outSize += GPBComputeSizeTSizeAsInt32NoTag(dataSize); + } else { + context->outSize += count * tagSize; + } + } else if (fieldType == GPBFieldTypeSingle) { + BOOL selfHas = GPBGetHasIvarField(context->self, field); + if (selfHas) { + double selfVal = GPBGetDoubleIvarWithField(context->self, field); + context->outSize += GPBComputeDoubleSize(GPBFieldNumber(field), selfVal); + } + } else { // fieldType == GPBFieldTypeMap + // Type will be GPB*DoubleDictionary, exact type doesn't matter. + GPBInt32DoubleDictionary *map = + GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + context->outSize += [map computeSerializedSizeAsField:field]; + } + return YES; +} + +//%PDDM-EXPAND SERIALIZED_SIZE_OBJECT_FUNC(String) +// This block of code is generated, do not edit it directly. + +static BOOL DynamicSerializedSizeString(GPBFieldDescriptor *field, + void *voidContext) { + SerializedSizeContext *context = (SerializedSizeContext *)voidContext; + GPBFieldType fieldType = field.fieldType; + if (fieldType == GPBFieldTypeRepeated) { + NSArray *array = + GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + for (id value in array) { + context->outSize += GPBComputeStringSizeNoTag(value); + } + size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), + GPBGetFieldType(field)); + context->outSize += array.count * tagSize; + } else if (fieldType == GPBFieldTypeSingle) { + BOOL selfHas = GPBGetHasIvarField(context->self, field); + if (selfHas) { + // GPBGetObjectIvarWithFieldNoAutocreate() avoids doing the has check + // again. + id selfVal = GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + context->outSize += GPBComputeStringSize(GPBFieldNumber(field), selfVal); + } + } else { // fieldType == GPBFieldTypeMap + GPBType mapKeyType = field.mapKeyType; + if (mapKeyType == GPBTypeString) { + // If key type was string, then the map is an NSDictionary. + NSDictionary *map = + GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + context->outSize += GPBDictionaryComputeSizeInternalHelper(map, field); + } else { + // Type will be GPB*StringDictionary, exact type doesn't matter. + GPBInt32ObjectDictionary *map = + GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + context->outSize += [map computeSerializedSizeAsField:field]; + } + } + return YES; +} + +//%PDDM-EXPAND SERIALIZED_SIZE_OBJECT_FUNC(Data) +// This block of code is generated, do not edit it directly. + +static BOOL DynamicSerializedSizeData(GPBFieldDescriptor *field, + void *voidContext) { + SerializedSizeContext *context = (SerializedSizeContext *)voidContext; + GPBFieldType fieldType = field.fieldType; + if (fieldType == GPBFieldTypeRepeated) { + NSArray *array = + GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + for (id value in array) { + context->outSize += GPBComputeDataSizeNoTag(value); + } + size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), + GPBGetFieldType(field)); + context->outSize += array.count * tagSize; + } else if (fieldType == GPBFieldTypeSingle) { + BOOL selfHas = GPBGetHasIvarField(context->self, field); + if (selfHas) { + // GPBGetObjectIvarWithFieldNoAutocreate() avoids doing the has check + // again. + id selfVal = GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + context->outSize += GPBComputeDataSize(GPBFieldNumber(field), selfVal); + } + } else { // fieldType == GPBFieldTypeMap + GPBType mapKeyType = field.mapKeyType; + if (mapKeyType == GPBTypeString) { + // If key type was string, then the map is an NSDictionary. + NSDictionary *map = + GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + context->outSize += GPBDictionaryComputeSizeInternalHelper(map, field); + } else { + // Type will be GPB*DataDictionary, exact type doesn't matter. + GPBInt32ObjectDictionary *map = + GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + context->outSize += [map computeSerializedSizeAsField:field]; + } + } + return YES; +} + +//%PDDM-EXPAND SERIALIZED_SIZE_OBJECT_FUNC(Message) +// This block of code is generated, do not edit it directly. + +static BOOL DynamicSerializedSizeMessage(GPBFieldDescriptor *field, + void *voidContext) { + SerializedSizeContext *context = (SerializedSizeContext *)voidContext; + GPBFieldType fieldType = field.fieldType; + if (fieldType == GPBFieldTypeRepeated) { + NSArray *array = + GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + for (id value in array) { + context->outSize += GPBComputeMessageSizeNoTag(value); + } + size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), + GPBGetFieldType(field)); + context->outSize += array.count * tagSize; + } else if (fieldType == GPBFieldTypeSingle) { + BOOL selfHas = GPBGetHasIvarField(context->self, field); + if (selfHas) { + // GPBGetObjectIvarWithFieldNoAutocreate() avoids doing the has check + // again. + id selfVal = GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + context->outSize += GPBComputeMessageSize(GPBFieldNumber(field), selfVal); + } + } else { // fieldType == GPBFieldTypeMap + GPBType mapKeyType = field.mapKeyType; + if (mapKeyType == GPBTypeString) { + // If key type was string, then the map is an NSDictionary. + NSDictionary *map = + GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + context->outSize += GPBDictionaryComputeSizeInternalHelper(map, field); + } else { + // Type will be GPB*MessageDictionary, exact type doesn't matter. + GPBInt32ObjectDictionary *map = + GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + context->outSize += [map computeSerializedSizeAsField:field]; + } + } + return YES; +} + +//%PDDM-EXPAND SERIALIZED_SIZE_OBJECT_FUNC(Group) +// This block of code is generated, do not edit it directly. + +static BOOL DynamicSerializedSizeGroup(GPBFieldDescriptor *field, + void *voidContext) { + SerializedSizeContext *context = (SerializedSizeContext *)voidContext; + GPBFieldType fieldType = field.fieldType; + if (fieldType == GPBFieldTypeRepeated) { + NSArray *array = + GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + for (id value in array) { + context->outSize += GPBComputeGroupSizeNoTag(value); + } + size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), + GPBGetFieldType(field)); + context->outSize += array.count * tagSize; + } else if (fieldType == GPBFieldTypeSingle) { + BOOL selfHas = GPBGetHasIvarField(context->self, field); + if (selfHas) { + // GPBGetObjectIvarWithFieldNoAutocreate() avoids doing the has check + // again. + id selfVal = GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + context->outSize += GPBComputeGroupSize(GPBFieldNumber(field), selfVal); + } + } else { // fieldType == GPBFieldTypeMap + GPBType mapKeyType = field.mapKeyType; + if (mapKeyType == GPBTypeString) { + // If key type was string, then the map is an NSDictionary. + NSDictionary *map = + GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + context->outSize += GPBDictionaryComputeSizeInternalHelper(map, field); + } else { + // Type will be GPB*GroupDictionary, exact type doesn't matter. + GPBInt32ObjectDictionary *map = + GPBGetObjectIvarWithFieldNoAutocreate(context->self, field); + context->outSize += [map computeSerializedSizeAsField:field]; + } + } + return YES; +} + +//%PDDM-EXPAND-END (18 expansions) + +- (size_t)serializedSize { + // Fields. + SerializedSizeContext context = {self, 0}; + GPBApplyStrictFunctions funcs = + GPBAPPLY_STRICT_FUNCTIONS_INIT(DynamicSerializedSize); + GPBApplyStrictFunctionsToMessageFields(&funcs, self, &context); + // Add any unknown fields. + const GPBDescriptor *descriptor = [self descriptor]; + if (descriptor.wireFormat) { + context.outSize += [unknownFields_ serializedSizeAsMessageSet]; + } else { + context.outSize += [unknownFields_ serializedSize]; + } + // Add any extensions. + for (GPBExtensionField *extension in extensionMap_) { + id value = [extensionMap_ objectForKey:extension]; + context.outSize += [extension computeSerializedSizeIncludingTag:value]; + } + + return context.outSize; +} + +#pragma mark - Resolve Methods Support + +typedef struct IvarAccessorMethodContext { + GPBFileSyntax syntax; + IMP impToAdd; + SEL encodingSelector; +} IvarAccessorMethodContext; + +//%PDDM-DEFINE IVAR_ACCESSOR_FUNC_COMMON(NAME, TYPE, TRUE_NAME) +//%static BOOL IvarGet##NAME(GPBFieldDescriptor *field, void *voidContext) { +//% IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext; +//% context->impToAdd = imp_implementationWithBlock(^(id obj) { +//% return GPBGet##TRUE_NAME##IvarWithField(obj, field); +//% }); +//% context->encodingSelector = @selector(get##NAME); +//% return NO; +//%} +//% +//%PDDM-DEFINE IVAR_ACCESSOR_FUNC_OBJECT(NAME, TYPE) +//%IVAR_ACCESSOR_FUNC_COMMON(NAME, TYPE, Object) +//%static BOOL IvarSet##NAME(GPBFieldDescriptor *field, void *voidContext) { +//% IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext; +//% // Local for syntax so the block doesn't capture context and use random +//% // memory in the future. +//% const GPBFileSyntax syntax = context->syntax; +//% context->impToAdd = imp_implementationWithBlock(^(id obj, TYPE value) { +//% return GPBSetObjectIvarWithFieldInternal(obj, field, value, syntax); +//% }); +//% context->encodingSelector = @selector(set##NAME:); +//% return NO; +//%} +//% +//%PDDM-DEFINE IVAR_ACCESSOR_FUNC_PER_VERSION(NAME, TYPE) +//%IVAR_ACCESSOR_FUNC_PER_VERSION_ALIASED(NAME, TYPE, NAME) +//%PDDM-DEFINE IVAR_ACCESSOR_FUNC_PER_VERSION_ALIASED(NAME, TYPE, TRUE_NAME) +//%IVAR_ACCESSOR_FUNC_COMMON(NAME, TYPE, TRUE_NAME) +//%static BOOL IvarSet##NAME(GPBFieldDescriptor *field, void *voidContext) { +//% IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext; +//% // Local for syntax so the block doesn't capture context and use random +//% // memory in the future. +//% const GPBFileSyntax syntax = context->syntax; +//% context->impToAdd = imp_implementationWithBlock(^(id obj, TYPE value) { +//% return GPBSet##TRUE_NAME##IvarWithFieldInternal(obj, field, value, syntax); +//% }); +//% context->encodingSelector = @selector(set##NAME:); +//% return NO; +//%} +//% +//%PDDM-EXPAND IVAR_ACCESSOR_FUNC_PER_VERSION(Bool, BOOL) +// This block of code is generated, do not edit it directly. + +static BOOL IvarGetBool(GPBFieldDescriptor *field, void *voidContext) { + IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext; + context->impToAdd = imp_implementationWithBlock(^(id obj) { + return GPBGetBoolIvarWithField(obj, field); + }); + context->encodingSelector = @selector(getBool); + return NO; +} + +static BOOL IvarSetBool(GPBFieldDescriptor *field, void *voidContext) { + IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext; + // Local for syntax so the block doesn't capture context and use random + // memory in the future. + const GPBFileSyntax syntax = context->syntax; + context->impToAdd = imp_implementationWithBlock(^(id obj, BOOL value) { + return GPBSetBoolIvarWithFieldInternal(obj, field, value, syntax); + }); + context->encodingSelector = @selector(setBool:); + return NO; +} + +//%PDDM-EXPAND IVAR_ACCESSOR_FUNC_PER_VERSION(Int32, int32_t) +// This block of code is generated, do not edit it directly. + +static BOOL IvarGetInt32(GPBFieldDescriptor *field, void *voidContext) { + IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext; + context->impToAdd = imp_implementationWithBlock(^(id obj) { + return GPBGetInt32IvarWithField(obj, field); + }); + context->encodingSelector = @selector(getInt32); + return NO; +} + +static BOOL IvarSetInt32(GPBFieldDescriptor *field, void *voidContext) { + IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext; + // Local for syntax so the block doesn't capture context and use random + // memory in the future. + const GPBFileSyntax syntax = context->syntax; + context->impToAdd = imp_implementationWithBlock(^(id obj, int32_t value) { + return GPBSetInt32IvarWithFieldInternal(obj, field, value, syntax); + }); + context->encodingSelector = @selector(setInt32:); + return NO; +} + +//%PDDM-EXPAND IVAR_ACCESSOR_FUNC_PER_VERSION_ALIASED(SInt32, int32_t, Int32) +// This block of code is generated, do not edit it directly. + +static BOOL IvarGetSInt32(GPBFieldDescriptor *field, void *voidContext) { + IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext; + context->impToAdd = imp_implementationWithBlock(^(id obj) { + return GPBGetInt32IvarWithField(obj, field); + }); + context->encodingSelector = @selector(getSInt32); + return NO; +} + +static BOOL IvarSetSInt32(GPBFieldDescriptor *field, void *voidContext) { + IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext; + // Local for syntax so the block doesn't capture context and use random + // memory in the future. + const GPBFileSyntax syntax = context->syntax; + context->impToAdd = imp_implementationWithBlock(^(id obj, int32_t value) { + return GPBSetInt32IvarWithFieldInternal(obj, field, value, syntax); + }); + context->encodingSelector = @selector(setSInt32:); + return NO; +} + +//%PDDM-EXPAND IVAR_ACCESSOR_FUNC_PER_VERSION_ALIASED(SFixed32, int32_t, Int32) +// This block of code is generated, do not edit it directly. + +static BOOL IvarGetSFixed32(GPBFieldDescriptor *field, void *voidContext) { + IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext; + context->impToAdd = imp_implementationWithBlock(^(id obj) { + return GPBGetInt32IvarWithField(obj, field); + }); + context->encodingSelector = @selector(getSFixed32); + return NO; +} + +static BOOL IvarSetSFixed32(GPBFieldDescriptor *field, void *voidContext) { + IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext; + // Local for syntax so the block doesn't capture context and use random + // memory in the future. + const GPBFileSyntax syntax = context->syntax; + context->impToAdd = imp_implementationWithBlock(^(id obj, int32_t value) { + return GPBSetInt32IvarWithFieldInternal(obj, field, value, syntax); + }); + context->encodingSelector = @selector(setSFixed32:); + return NO; +} + +//%PDDM-EXPAND IVAR_ACCESSOR_FUNC_PER_VERSION(UInt32, uint32_t) +// This block of code is generated, do not edit it directly. + +static BOOL IvarGetUInt32(GPBFieldDescriptor *field, void *voidContext) { + IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext; + context->impToAdd = imp_implementationWithBlock(^(id obj) { + return GPBGetUInt32IvarWithField(obj, field); + }); + context->encodingSelector = @selector(getUInt32); + return NO; +} + +static BOOL IvarSetUInt32(GPBFieldDescriptor *field, void *voidContext) { + IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext; + // Local for syntax so the block doesn't capture context and use random + // memory in the future. + const GPBFileSyntax syntax = context->syntax; + context->impToAdd = imp_implementationWithBlock(^(id obj, uint32_t value) { + return GPBSetUInt32IvarWithFieldInternal(obj, field, value, syntax); + }); + context->encodingSelector = @selector(setUInt32:); + return NO; +} + +//%PDDM-EXPAND IVAR_ACCESSOR_FUNC_PER_VERSION_ALIASED(Fixed32, uint32_t, UInt32) +// This block of code is generated, do not edit it directly. + +static BOOL IvarGetFixed32(GPBFieldDescriptor *field, void *voidContext) { + IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext; + context->impToAdd = imp_implementationWithBlock(^(id obj) { + return GPBGetUInt32IvarWithField(obj, field); + }); + context->encodingSelector = @selector(getFixed32); + return NO; +} + +static BOOL IvarSetFixed32(GPBFieldDescriptor *field, void *voidContext) { + IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext; + // Local for syntax so the block doesn't capture context and use random + // memory in the future. + const GPBFileSyntax syntax = context->syntax; + context->impToAdd = imp_implementationWithBlock(^(id obj, uint32_t value) { + return GPBSetUInt32IvarWithFieldInternal(obj, field, value, syntax); + }); + context->encodingSelector = @selector(setFixed32:); + return NO; +} + +//%PDDM-EXPAND IVAR_ACCESSOR_FUNC_PER_VERSION(Int64, int64_t) +// This block of code is generated, do not edit it directly. + +static BOOL IvarGetInt64(GPBFieldDescriptor *field, void *voidContext) { + IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext; + context->impToAdd = imp_implementationWithBlock(^(id obj) { + return GPBGetInt64IvarWithField(obj, field); + }); + context->encodingSelector = @selector(getInt64); + return NO; +} + +static BOOL IvarSetInt64(GPBFieldDescriptor *field, void *voidContext) { + IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext; + // Local for syntax so the block doesn't capture context and use random + // memory in the future. + const GPBFileSyntax syntax = context->syntax; + context->impToAdd = imp_implementationWithBlock(^(id obj, int64_t value) { + return GPBSetInt64IvarWithFieldInternal(obj, field, value, syntax); + }); + context->encodingSelector = @selector(setInt64:); + return NO; +} + +//%PDDM-EXPAND IVAR_ACCESSOR_FUNC_PER_VERSION_ALIASED(SFixed64, int64_t, Int64) +// This block of code is generated, do not edit it directly. + +static BOOL IvarGetSFixed64(GPBFieldDescriptor *field, void *voidContext) { + IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext; + context->impToAdd = imp_implementationWithBlock(^(id obj) { + return GPBGetInt64IvarWithField(obj, field); + }); + context->encodingSelector = @selector(getSFixed64); + return NO; +} + +static BOOL IvarSetSFixed64(GPBFieldDescriptor *field, void *voidContext) { + IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext; + // Local for syntax so the block doesn't capture context and use random + // memory in the future. + const GPBFileSyntax syntax = context->syntax; + context->impToAdd = imp_implementationWithBlock(^(id obj, int64_t value) { + return GPBSetInt64IvarWithFieldInternal(obj, field, value, syntax); + }); + context->encodingSelector = @selector(setSFixed64:); + return NO; +} + +//%PDDM-EXPAND IVAR_ACCESSOR_FUNC_PER_VERSION_ALIASED(SInt64, int64_t, Int64) +// This block of code is generated, do not edit it directly. + +static BOOL IvarGetSInt64(GPBFieldDescriptor *field, void *voidContext) { + IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext; + context->impToAdd = imp_implementationWithBlock(^(id obj) { + return GPBGetInt64IvarWithField(obj, field); + }); + context->encodingSelector = @selector(getSInt64); + return NO; +} + +static BOOL IvarSetSInt64(GPBFieldDescriptor *field, void *voidContext) { + IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext; + // Local for syntax so the block doesn't capture context and use random + // memory in the future. + const GPBFileSyntax syntax = context->syntax; + context->impToAdd = imp_implementationWithBlock(^(id obj, int64_t value) { + return GPBSetInt64IvarWithFieldInternal(obj, field, value, syntax); + }); + context->encodingSelector = @selector(setSInt64:); + return NO; +} + +//%PDDM-EXPAND IVAR_ACCESSOR_FUNC_PER_VERSION(UInt64, uint64_t) +// This block of code is generated, do not edit it directly. + +static BOOL IvarGetUInt64(GPBFieldDescriptor *field, void *voidContext) { + IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext; + context->impToAdd = imp_implementationWithBlock(^(id obj) { + return GPBGetUInt64IvarWithField(obj, field); + }); + context->encodingSelector = @selector(getUInt64); + return NO; +} + +static BOOL IvarSetUInt64(GPBFieldDescriptor *field, void *voidContext) { + IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext; + // Local for syntax so the block doesn't capture context and use random + // memory in the future. + const GPBFileSyntax syntax = context->syntax; + context->impToAdd = imp_implementationWithBlock(^(id obj, uint64_t value) { + return GPBSetUInt64IvarWithFieldInternal(obj, field, value, syntax); + }); + context->encodingSelector = @selector(setUInt64:); + return NO; +} + +//%PDDM-EXPAND IVAR_ACCESSOR_FUNC_PER_VERSION_ALIASED(Fixed64, uint64_t, UInt64) +// This block of code is generated, do not edit it directly. + +static BOOL IvarGetFixed64(GPBFieldDescriptor *field, void *voidContext) { + IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext; + context->impToAdd = imp_implementationWithBlock(^(id obj) { + return GPBGetUInt64IvarWithField(obj, field); + }); + context->encodingSelector = @selector(getFixed64); + return NO; +} + +static BOOL IvarSetFixed64(GPBFieldDescriptor *field, void *voidContext) { + IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext; + // Local for syntax so the block doesn't capture context and use random + // memory in the future. + const GPBFileSyntax syntax = context->syntax; + context->impToAdd = imp_implementationWithBlock(^(id obj, uint64_t value) { + return GPBSetUInt64IvarWithFieldInternal(obj, field, value, syntax); + }); + context->encodingSelector = @selector(setFixed64:); + return NO; +} + +//%PDDM-EXPAND IVAR_ACCESSOR_FUNC_PER_VERSION(Float, float) +// This block of code is generated, do not edit it directly. + +static BOOL IvarGetFloat(GPBFieldDescriptor *field, void *voidContext) { + IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext; + context->impToAdd = imp_implementationWithBlock(^(id obj) { + return GPBGetFloatIvarWithField(obj, field); + }); + context->encodingSelector = @selector(getFloat); + return NO; +} + +static BOOL IvarSetFloat(GPBFieldDescriptor *field, void *voidContext) { + IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext; + // Local for syntax so the block doesn't capture context and use random + // memory in the future. + const GPBFileSyntax syntax = context->syntax; + context->impToAdd = imp_implementationWithBlock(^(id obj, float value) { + return GPBSetFloatIvarWithFieldInternal(obj, field, value, syntax); + }); + context->encodingSelector = @selector(setFloat:); + return NO; +} + +//%PDDM-EXPAND IVAR_ACCESSOR_FUNC_PER_VERSION(Double, double) +// This block of code is generated, do not edit it directly. + +static BOOL IvarGetDouble(GPBFieldDescriptor *field, void *voidContext) { + IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext; + context->impToAdd = imp_implementationWithBlock(^(id obj) { + return GPBGetDoubleIvarWithField(obj, field); + }); + context->encodingSelector = @selector(getDouble); + return NO; +} + +static BOOL IvarSetDouble(GPBFieldDescriptor *field, void *voidContext) { + IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext; + // Local for syntax so the block doesn't capture context and use random + // memory in the future. + const GPBFileSyntax syntax = context->syntax; + context->impToAdd = imp_implementationWithBlock(^(id obj, double value) { + return GPBSetDoubleIvarWithFieldInternal(obj, field, value, syntax); + }); + context->encodingSelector = @selector(setDouble:); + return NO; +} + +//%PDDM-EXPAND IVAR_ACCESSOR_FUNC_OBJECT(String, id) +// This block of code is generated, do not edit it directly. + +static BOOL IvarGetString(GPBFieldDescriptor *field, void *voidContext) { + IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext; + context->impToAdd = imp_implementationWithBlock(^(id obj) { + return GPBGetObjectIvarWithField(obj, field); + }); + context->encodingSelector = @selector(getString); + return NO; +} + +static BOOL IvarSetString(GPBFieldDescriptor *field, void *voidContext) { + IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext; + // Local for syntax so the block doesn't capture context and use random + // memory in the future. + const GPBFileSyntax syntax = context->syntax; + context->impToAdd = imp_implementationWithBlock(^(id obj, id value) { + return GPBSetObjectIvarWithFieldInternal(obj, field, value, syntax); + }); + context->encodingSelector = @selector(setString:); + return NO; +} + +//%PDDM-EXPAND IVAR_ACCESSOR_FUNC_OBJECT(Data, id) +// This block of code is generated, do not edit it directly. + +static BOOL IvarGetData(GPBFieldDescriptor *field, void *voidContext) { + IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext; + context->impToAdd = imp_implementationWithBlock(^(id obj) { + return GPBGetObjectIvarWithField(obj, field); + }); + context->encodingSelector = @selector(getData); + return NO; +} + +static BOOL IvarSetData(GPBFieldDescriptor *field, void *voidContext) { + IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext; + // Local for syntax so the block doesn't capture context and use random + // memory in the future. + const GPBFileSyntax syntax = context->syntax; + context->impToAdd = imp_implementationWithBlock(^(id obj, id value) { + return GPBSetObjectIvarWithFieldInternal(obj, field, value, syntax); + }); + context->encodingSelector = @selector(setData:); + return NO; +} + +//%PDDM-EXPAND IVAR_ACCESSOR_FUNC_OBJECT(Message, id) +// This block of code is generated, do not edit it directly. + +static BOOL IvarGetMessage(GPBFieldDescriptor *field, void *voidContext) { + IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext; + context->impToAdd = imp_implementationWithBlock(^(id obj) { + return GPBGetObjectIvarWithField(obj, field); + }); + context->encodingSelector = @selector(getMessage); + return NO; +} + +static BOOL IvarSetMessage(GPBFieldDescriptor *field, void *voidContext) { + IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext; + // Local for syntax so the block doesn't capture context and use random + // memory in the future. + const GPBFileSyntax syntax = context->syntax; + context->impToAdd = imp_implementationWithBlock(^(id obj, id value) { + return GPBSetObjectIvarWithFieldInternal(obj, field, value, syntax); + }); + context->encodingSelector = @selector(setMessage:); + return NO; +} + +//%PDDM-EXPAND IVAR_ACCESSOR_FUNC_OBJECT(Group, id) +// This block of code is generated, do not edit it directly. + +static BOOL IvarGetGroup(GPBFieldDescriptor *field, void *voidContext) { + IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext; + context->impToAdd = imp_implementationWithBlock(^(id obj) { + return GPBGetObjectIvarWithField(obj, field); + }); + context->encodingSelector = @selector(getGroup); + return NO; +} + +static BOOL IvarSetGroup(GPBFieldDescriptor *field, void *voidContext) { + IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext; + // Local for syntax so the block doesn't capture context and use random + // memory in the future. + const GPBFileSyntax syntax = context->syntax; + context->impToAdd = imp_implementationWithBlock(^(id obj, id value) { + return GPBSetObjectIvarWithFieldInternal(obj, field, value, syntax); + }); + context->encodingSelector = @selector(setGroup:); + return NO; +} + +//%PDDM-EXPAND-END (17 expansions) + +// Enum gets custom hooks because get needs the syntax to Get. + +static BOOL IvarGetEnum(GPBFieldDescriptor *field, void *voidContext) { + IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext; + // Local for syntax so the block doesn't capture context and use random + // memory in the future. + const GPBFileSyntax syntax = context->syntax; + context->impToAdd = imp_implementationWithBlock(^(id obj) { + return GPBGetEnumIvarWithFieldInternal(obj, field, syntax); + }); + context->encodingSelector = @selector(getEnum); + return NO; +} + +static BOOL IvarSetEnum(GPBFieldDescriptor *field, void *voidContext) { + IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext; + // Local for syntax so the block doesn't capture context and use random + // memory in the future. + const GPBFileSyntax syntax = context->syntax; + context->impToAdd = imp_implementationWithBlock(^(id obj, int32_t value) { + return GPBSetEnumIvarWithFieldInternal(obj, field, value, syntax); + }); + context->encodingSelector = @selector(setEnum:); + return NO; +} + ++ (BOOL)resolveInstanceMethod:(SEL)sel { + const GPBDescriptor *descriptor = [self descriptor]; + if (!descriptor) { + return NO; + } + + // NOTE: hasSel_/setHasSel_ will be NULL if the field for the given message + // should not have has support (done in GPBDescriptor.m), so there is no need + // for checks here to see if has*/setHas* are allowed. + + IvarAccessorMethodContext context = {descriptor.file.syntax, NULL, NULL}; + for (GPBFieldDescriptor *field in descriptor->fields_) { + BOOL isMapOrArray = GPBFieldIsMapOrArray(field); + if (!isMapOrArray) { + if (sel == field->getSel_) { + static const GPBApplyStrictFunctions funcs = + GPBAPPLY_STRICT_FUNCTIONS_INIT(IvarGet); + funcs[GPBGetFieldType(field)](field, &context); + break; + } else if (sel == field->hasSel_) { + int32_t index = GPBFieldHasIndex(field); + uint32_t fieldNum = GPBFieldNumber(field); + context.impToAdd = imp_implementationWithBlock(^(id obj) { + return GPBGetHasIvar(obj, index, fieldNum); + }); + context.encodingSelector = @selector(getBool); + break; + } else if (sel == field->setHasSel_) { + context.impToAdd = imp_implementationWithBlock(^(id obj, BOOL value) { + if (value) { + [NSException raise:NSInvalidArgumentException + format:@"has fields can only be set to NO"]; + } + GPBClearMessageField(obj, field); + }); + context.encodingSelector = @selector(setBool:); + break; + } else if (sel == field->setSel_) { + GPBApplyStrictFunctions funcs = GPBAPPLY_STRICT_FUNCTIONS_INIT(IvarSet); + funcs[GPBGetFieldType(field)](field, &context); + break; + } else { + GPBOneofDescriptor *oneof = field->containingOneof_; + if (oneof && (sel == oneof->caseSel_)) { + int32_t index = oneof->oneofDescription_->index; + context.impToAdd = imp_implementationWithBlock(^(id obj) { + return GPBGetHasOneof(obj, index); + }); + context.encodingSelector = @selector(getEnum); + break; + } + } + } else { + if (sel == field->getSel_) { + context.impToAdd = imp_implementationWithBlock(^(id obj) { + return GetArrayIvarWithField(obj, field); + }); + context.encodingSelector = @selector(getArray); + break; + } else if (sel == field->setSel_) { + // Local for syntax so the block doesn't capture context and use random + // memory in the future. + const GPBFileSyntax syntax = context.syntax; + context.impToAdd = imp_implementationWithBlock(^(id obj, id value) { + return GPBSetObjectIvarWithFieldInternal(obj, field, value, syntax); + }); + context.encodingSelector = @selector(setArray:); + break; + } + } + } + if (context.impToAdd) { + const char *encoding = + GPBMessageEncodingForSelector(context.encodingSelector, YES); + BOOL methodAdded = class_addMethod(descriptor.messageClass, sel, + context.impToAdd, encoding); + return methodAdded; + } + return [super resolveInstanceMethod:sel]; +} + +#pragma mark - NSCoding Support + +- (instancetype)initWithCoder:(NSCoder *)aDecoder { + self = [self init]; + if (self) { + [self mergeFromData:[aDecoder decodeDataObject] extensionRegistry:nil]; + } + return self; +} + +- (void)encodeWithCoder:(NSCoder *)aCoder { + [aCoder encodeDataObject:[self data]]; +} + +#pragma mark - KVC Support + ++ (BOOL)accessInstanceVariablesDirectly { + // Make sure KVC doesn't use instance variables. + return NO; +} + +@end -- cgit v1.2.3