blob: 8134e25962dcb28c3b7b5258142ec251c078489f [file] [log] [blame]
// 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 <objc/runtime.h>
#import <objc/message.h>
#import "GPBArray_PackagePrivate.h"
#import "GPBCodedInputStream_PackagePrivate.h"
#import "GPBCodedOutputStream_PackagePrivate.h"
#import "GPBDescriptor_PackagePrivate.h"
#import "GPBDictionary_PackagePrivate.h"
#import "GPBExtensionInternals.h"
#import "GPBExtensionRegistry.h"
#import "GPBRootObject_PackagePrivate.h"
#import "GPBUnknownFieldSet_PackagePrivate.h"
#import "GPBUtilities_PackagePrivate.h"
NSString *const GPBMessageErrorDomain =
GPBNSStringifySymbol(GPBMessageErrorDomain);
#ifdef DEBUG
NSString *const GPBExceptionMessageKey =
GPBNSStringifySymbol(GPBExceptionMessage);
#endif // DEBUG
static NSString *const kGPBDataCoderKey = @"GPBData";
//
// 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_;
GPBExtensionDescriptor *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 CreateMapForField(GPBFieldDescriptor *field,
GPBMessage *autocreator)
__attribute__((ns_returns_retained));
static id GetOrCreateMapIvarWithField(GPBMessage *self,
GPBFieldDescriptor *field,
GPBFileSyntax syntax);
static id GetMapIvarWithField(GPBMessage *self, GPBFieldDescriptor *field);
static NSMutableDictionary *CloneExtensionMap(NSDictionary *extensionMap,
NSZone *zone)
__attribute__((ns_returns_retained));
static NSError *MessageError(NSInteger code, NSDictionary *userInfo) {
return [NSError errorWithDomain:GPBMessageErrorDomain
code:code
userInfo:userInfo];
}
static NSError *MessageErrorWithReason(NSInteger code, NSString *reason) {
NSDictionary *userInfo = nil;
if ([reason length]) {
userInfo = @{ @"Reason" : reason };
}
return MessageError(code, userInfo);
}
static void CheckExtension(GPBMessage *self,
GPBExtensionDescriptor *extension) {
if ([self class] != extension.containingMessageClass) {
[NSException
raise:NSInvalidArgumentException
format:@"Extension %@ used on wrong class (%@ instead of %@)",
extension.singletonName,
[self class], extension.containingMessageClass];
}
}
static NSMutableDictionary *CloneExtensionMap(NSDictionary *extensionMap,
NSZone *zone) {
if (extensionMap.count == 0) {
return nil;
}
NSMutableDictionary *result = [[NSMutableDictionary allocWithZone:zone]
initWithCapacity:extensionMap.count];
for (GPBExtensionDescriptor *extension in extensionMap) {
id value = [extensionMap objectForKey:extension];
BOOL isMessageExtension = GPBExtensionIsMessage(extension);
if (extension.repeated) {
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:extension];
[list release];
} else {
NSMutableArray *copiedValue = [value mutableCopyWithZone:zone];
[result setObject:copiedValue forKey:extension];
[copiedValue release];
}
} else {
if (isMessageExtension) {
GPBMessage *copiedValue = [value copyWithZone:zone];
[result setObject:copiedValue forKey:extension];
[copiedValue release];
} else {
[result setObject:value forKey:extension];
}
}
}
return result;
}
static id CreateArrayForField(GPBFieldDescriptor *field,
GPBMessage *autocreator) {
id result;
GPBDataType fieldDataType = GPBGetFieldDataType(field);
switch (fieldDataType) {
case GPBDataTypeBool:
result = [[GPBBoolArray alloc] init];
break;
case GPBDataTypeFixed32:
case GPBDataTypeUInt32:
result = [[GPBUInt32Array alloc] init];
break;
case GPBDataTypeInt32:
case GPBDataTypeSFixed32:
case GPBDataTypeSInt32:
result = [[GPBInt32Array alloc] init];
break;
case GPBDataTypeFixed64:
case GPBDataTypeUInt64:
result = [[GPBUInt64Array alloc] init];
break;
case GPBDataTypeInt64:
case GPBDataTypeSFixed64:
case GPBDataTypeSInt64:
result = [[GPBInt64Array alloc] init];
break;
case GPBDataTypeFloat:
result = [[GPBFloatArray alloc] init];
break;
case GPBDataTypeDouble:
result = [[GPBDoubleArray alloc] init];
break;
case GPBDataTypeEnum:
result = [[GPBEnumArray alloc]
initWithValidationFunction:field.enumDescriptor.enumVerifier];
break;
case GPBDataTypeBytes:
case GPBDataTypeGroup:
case GPBDataTypeMessage:
case GPBDataTypeString:
if (autocreator) {
result = [[GPBAutocreatedArray alloc] init];
} else {
result = [[NSMutableArray alloc] init];
}
break;
}
if (autocreator) {
if (GPBDataTypeIsObject(fieldDataType)) {
GPBAutocreatedArray *autoArray = result;
autoArray->_autocreator = autocreator;
} else {
GPBInt32Array *gpbArray = result;
gpbArray->_autocreator = autocreator;
}
}
return result;
}
static id CreateMapForField(GPBFieldDescriptor *field,
GPBMessage *autocreator) {
id result;
GPBDataType keyDataType = field.mapKeyDataType;
GPBDataType valueDataType = GPBGetFieldDataType(field);
switch (keyDataType) {
case GPBDataTypeBool:
switch (valueDataType) {
case GPBDataTypeBool:
result = [[GPBBoolBoolDictionary alloc] init];
break;
case GPBDataTypeFixed32:
case GPBDataTypeUInt32:
result = [[GPBBoolUInt32Dictionary alloc] init];
break;
case GPBDataTypeInt32:
case GPBDataTypeSFixed32:
case GPBDataTypeSInt32:
result = [[GPBBoolInt32Dictionary alloc] init];
break;
case GPBDataTypeFixed64:
case GPBDataTypeUInt64:
result = [[GPBBoolUInt64Dictionary alloc] init];
break;
case GPBDataTypeInt64:
case GPBDataTypeSFixed64:
case GPBDataTypeSInt64:
result = [[GPBBoolInt64Dictionary alloc] init];
break;
case GPBDataTypeFloat:
result = [[GPBBoolFloatDictionary alloc] init];
break;
case GPBDataTypeDouble:
result = [[GPBBoolDoubleDictionary alloc] init];
break;
case GPBDataTypeEnum:
result = [[GPBBoolEnumDictionary alloc]
initWithValidationFunction:field.enumDescriptor.enumVerifier];
break;
case GPBDataTypeBytes:
case GPBDataTypeMessage:
case GPBDataTypeString:
result = [[GPBBoolObjectDictionary alloc] init];
break;
case GPBDataTypeGroup:
NSCAssert(NO, @"shouldn't happen");
return nil;
}
break;
case GPBDataTypeFixed32:
case GPBDataTypeUInt32:
switch (valueDataType) {
case GPBDataTypeBool:
result = [[GPBUInt32BoolDictionary alloc] init];
break;
case GPBDataTypeFixed32:
case GPBDataTypeUInt32:
result = [[GPBUInt32UInt32Dictionary alloc] init];
break;
case GPBDataTypeInt32:
case GPBDataTypeSFixed32:
case GPBDataTypeSInt32:
result = [[GPBUInt32Int32Dictionary alloc] init];
break;
case GPBDataTypeFixed64:
case GPBDataTypeUInt64:
result = [[GPBUInt32UInt64Dictionary alloc] init];
break;
case GPBDataTypeInt64:
case GPBDataTypeSFixed64:
case GPBDataTypeSInt64:
result = [[GPBUInt32Int64Dictionary alloc] init];
break;
case GPBDataTypeFloat:
result = [[GPBUInt32FloatDictionary alloc] init];
break;
case GPBDataTypeDouble:
result = [[GPBUInt32DoubleDictionary alloc] init];
break;
case GPBDataTypeEnum:
result = [[GPBUInt32EnumDictionary alloc]
initWithValidationFunction:field.enumDescriptor.enumVerifier];
break;
case GPBDataTypeBytes:
case GPBDataTypeMessage:
case GPBDataTypeString:
result = [[GPBUInt32ObjectDictionary alloc] init];
break;
case GPBDataTypeGroup:
NSCAssert(NO, @"shouldn't happen");
return nil;
}
break;
case GPBDataTypeInt32:
case GPBDataTypeSFixed32:
case GPBDataTypeSInt32:
switch (valueDataType) {
case GPBDataTypeBool:
result = [[GPBInt32BoolDictionary alloc] init];
break;
case GPBDataTypeFixed32:
case GPBDataTypeUInt32:
result = [[GPBInt32UInt32Dictionary alloc] init];
break;
case GPBDataTypeInt32:
case GPBDataTypeSFixed32:
case GPBDataTypeSInt32:
result = [[GPBInt32Int32Dictionary alloc] init];
break;
case GPBDataTypeFixed64:
case GPBDataTypeUInt64:
result = [[GPBInt32UInt64Dictionary alloc] init];
break;
case GPBDataTypeInt64:
case GPBDataTypeSFixed64:
case GPBDataTypeSInt64:
result = [[GPBInt32Int64Dictionary alloc] init];
break;
case GPBDataTypeFloat:
result = [[GPBInt32FloatDictionary alloc] init];
break;
case GPBDataTypeDouble:
result = [[GPBInt32DoubleDictionary alloc] init];
break;
case GPBDataTypeEnum:
result = [[GPBInt32EnumDictionary alloc]
initWithValidationFunction:field.enumDescriptor.enumVerifier];
break;
case GPBDataTypeBytes:
case GPBDataTypeMessage:
case GPBDataTypeString:
result = [[GPBInt32ObjectDictionary alloc] init];
break;
case GPBDataTypeGroup:
NSCAssert(NO, @"shouldn't happen");
return nil;
}
break;
case GPBDataTypeFixed64:
case GPBDataTypeUInt64:
switch (valueDataType) {
case GPBDataTypeBool:
result = [[GPBUInt64BoolDictionary alloc] init];
break;
case GPBDataTypeFixed32:
case GPBDataTypeUInt32:
result = [[GPBUInt64UInt32Dictionary alloc] init];
break;
case GPBDataTypeInt32:
case GPBDataTypeSFixed32:
case GPBDataTypeSInt32:
result = [[GPBUInt64Int32Dictionary alloc] init];
break;
case GPBDataTypeFixed64:
case GPBDataTypeUInt64:
result = [[GPBUInt64UInt64Dictionary alloc] init];
break;
case GPBDataTypeInt64:
case GPBDataTypeSFixed64:
case GPBDataTypeSInt64:
result = [[GPBUInt64Int64Dictionary alloc] init];
break;
case GPBDataTypeFloat:
result = [[GPBUInt64FloatDictionary alloc] init];
break;
case GPBDataTypeDouble:
result = [[GPBUInt64DoubleDictionary alloc] init];
break;
case GPBDataTypeEnum:
result = [[GPBUInt64EnumDictionary alloc]
initWithValidationFunction:field.enumDescriptor.enumVerifier];
break;
case GPBDataTypeBytes:
case GPBDataTypeMessage:
case GPBDataTypeString:
result = [[GPBUInt64ObjectDictionary alloc] init];
break;
case GPBDataTypeGroup:
NSCAssert(NO, @"shouldn't happen");
return nil;
}
break;
case GPBDataTypeInt64:
case GPBDataTypeSFixed64:
case GPBDataTypeSInt64:
switch (valueDataType) {
case GPBDataTypeBool:
result = [[GPBInt64BoolDictionary alloc] init];
break;
case GPBDataTypeFixed32:
case GPBDataTypeUInt32:
result = [[GPBInt64UInt32Dictionary alloc] init];
break;
case GPBDataTypeInt32:
case GPBDataTypeSFixed32:
case GPBDataTypeSInt32:
result = [[GPBInt64Int32Dictionary alloc] init];
break;
case GPBDataTypeFixed64:
case GPBDataTypeUInt64:
result = [[GPBInt64UInt64Dictionary alloc] init];
break;
case GPBDataTypeInt64:
case GPBDataTypeSFixed64:
case GPBDataTypeSInt64:
result = [[GPBInt64Int64Dictionary alloc] init];
break;
case GPBDataTypeFloat:
result = [[GPBInt64FloatDictionary alloc] init];
break;
case GPBDataTypeDouble:
result = [[GPBInt64DoubleDictionary alloc] init];
break;
case GPBDataTypeEnum:
result = [[GPBInt64EnumDictionary alloc]
initWithValidationFunction:field.enumDescriptor.enumVerifier];
break;
case GPBDataTypeBytes:
case GPBDataTypeMessage:
case GPBDataTypeString:
result = [[GPBInt64ObjectDictionary alloc] init];
break;
case GPBDataTypeGroup:
NSCAssert(NO, @"shouldn't happen");
return nil;
}
break;
case GPBDataTypeString:
switch (valueDataType) {
case GPBDataTypeBool:
result = [[GPBStringBoolDictionary alloc] init];
break;
case GPBDataTypeFixed32:
case GPBDataTypeUInt32:
result = [[GPBStringUInt32Dictionary alloc] init];
break;
case GPBDataTypeInt32:
case GPBDataTypeSFixed32:
case GPBDataTypeSInt32:
result = [[GPBStringInt32Dictionary alloc] init];
break;
case GPBDataTypeFixed64:
case GPBDataTypeUInt64:
result = [[GPBStringUInt64Dictionary alloc] init];
break;
case GPBDataTypeInt64:
case GPBDataTypeSFixed64:
case GPBDataTypeSInt64:
result = [[GPBStringInt64Dictionary alloc] init];
break;
case GPBDataTypeFloat:
result = [[GPBStringFloatDictionary alloc] init];
break;
case GPBDataTypeDouble:
result = [[GPBStringDoubleDictionary alloc] init];
break;
case GPBDataTypeEnum:
result = [[GPBStringEnumDictionary alloc]
initWithValidationFunction:field.enumDescriptor.enumVerifier];
break;
case GPBDataTypeBytes:
case GPBDataTypeMessage:
case GPBDataTypeString:
if (autocreator) {
result = [[GPBAutocreatedDictionary alloc] init];
} else {
result = [[NSMutableDictionary alloc] init];
}
break;
case GPBDataTypeGroup:
NSCAssert(NO, @"shouldn't happen");
return nil;
}
break;
case GPBDataTypeFloat:
case GPBDataTypeDouble:
case GPBDataTypeEnum:
case GPBDataTypeBytes:
case GPBDataTypeGroup:
case GPBDataTypeMessage:
NSCAssert(NO, @"shouldn't happen");
return nil;
}
if (autocreator) {
if ((keyDataType == GPBDataTypeString) &&
GPBDataTypeIsObject(valueDataType)) {
GPBAutocreatedDictionary *autoDict = result;
autoDict->_autocreator = autocreator;
} else {
GPBInt32Int32Dictionary *gpbDict = result;
gpbDict->_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.
GPBPrepareReadOnlySemaphore(self);
dispatch_semaphore_wait(self->readOnlySemaphore_, DISPATCH_TIME_FOREVER);
array = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
if (!array) {
array = CreateArrayForField(field, self);
GPBSetAutocreatedRetainedObjectIvarWithField(self, field, array);
}
dispatch_semaphore_signal(self->readOnlySemaphore_);
}
return array;
}
static id GetOrCreateMapIvarWithField(GPBMessage *self,
GPBFieldDescriptor *field,
GPBFileSyntax syntax) {
id dict = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
if (!dict) {
// No lock needed, this is called from places expecting to mutate
// so no threading protection is needed.
dict = CreateMapForField(field, nil);
GPBSetRetainedObjectIvarWithFieldInternal(self, field, dict, syntax);
}
return dict;
}
// This is like GPBGetObjectIvarWithField(), but for maps, it should
// only be used to wire the method into the class.
static id GetMapIvarWithField(GPBMessage *self, GPBFieldDescriptor *field) {
id dict = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
if (!dict) {
// Check again after getting the lock.
GPBPrepareReadOnlySemaphore(self);
dispatch_semaphore_wait(self->readOnlySemaphore_, DISPATCH_TIME_FOREVER);
dict = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
if (!dict) {
dict = CreateMapForField(field, self);
GPBSetAutocreatedRetainedObjectIvarWithField(self, field, dict);
}
dispatch_semaphore_signal(self->readOnlySemaphore_);
}
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, GPBExtensionDescriptor *extension)
__attribute__((ns_returns_retained));
static GPBMessage *CreateMessageWithAutocreatorForExtension(
Class msgClass, GPBMessage *autocreator,
GPBExtensionDescriptor *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 (GPBFieldDataTypeIsObject(field)) {
GPBAutocreatedArray *autoArray = array;
autoArray->_autocreator = nil;
} else {
GPBInt32Array *gpbArray = array;
gpbArray->_autocreator = nil;
}
GPBBecomeVisibleToAutocreator(self);
return;
}
}
}
NSCAssert(NO, @"Unknown autocreated %@ for %@.", [array class], self);
}
void GPBAutocreatedDictionaryModified(GPBMessage *self, id dictionary) {
// When one of our autocreated dicts adds elements, make it visible.
GPBDescriptor *descriptor = [[self class] descriptor];
for (GPBFieldDescriptor *field in descriptor->fields_) {
if (field.fieldType == GPBFieldTypeMap) {
id curDict = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
if (curDict == dictionary) {
if ((field.mapKeyDataType == GPBDataTypeString) &&
GPBFieldDataTypeIsObject(field)) {
GPBAutocreatedDictionary *autoDict = dictionary;
autoDict->_autocreator = nil;
} else {
GPBInt32Int32Dictionary *gpbDict = dictionary;
gpbDict->_autocreator = nil;
}
GPBBecomeVisibleToAutocreator(self);
return;
}
}
}
NSCAssert(NO, @"Unknown autocreated %@ for %@.", [dictionary class], self);
}
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, self: %@.",
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_;
}
@implementation GPBMessage
+ (void)initialize {
Class pbMessageClass = [GPBMessage class];
if ([self class] == pbMessageClass) {
// This is here to start up the "base" class descriptor.
[self descriptor];
// Message shares extension method resolving with GPBRootObject so insure
// it is started up at the same time.
(void)[GPBRootObject class];
} 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.
// Note: The generated code for -descriptor calls
// +[GPBDescriptor allocDescriptorForClass:...], passing the GPBRootObject
// subclass for the file. That call chain is what ensures that *Root class
// is started up to support extension resolution off the message class
// (+resolveClassMethod: below) in a thread safe manner.
[self descriptor];
}
}
+ (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
storageSize:0
flags:0];
}
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]));
}
return self;
}
- (instancetype)initWithData:(NSData *)data error:(NSError **)errorPtr {
return [self initWithData:data extensionRegistry:nil error:errorPtr];
}
- (instancetype)initWithData:(NSData *)data
extensionRegistry:(GPBExtensionRegistry *)extensionRegistry
error:(NSError **)errorPtr {
if ((self = [self init])) {
@try {
[self mergeFromData:data extensionRegistry:extensionRegistry];
if (errorPtr) {
*errorPtr = nil;
}
}
@catch (NSException *exception) {
[self release];
self = nil;
if (errorPtr) {
*errorPtr = MessageErrorWithReason(GPBMessageErrorCodeMalformedData,
exception.reason);
}
}
#ifdef DEBUG
if (self && !self.initialized) {
[self release];
self = nil;
if (errorPtr) {
*errorPtr = MessageError(GPBMessageErrorCodeMissingRequiredField, nil);
}
}
#endif
}
return self;
}
- (instancetype)initWithCodedInputStream:(GPBCodedInputStream *)input
extensionRegistry:
(GPBExtensionRegistry *)extensionRegistry
error:(NSError **)errorPtr {
if ((self = [self init])) {
@try {
[self mergeFromCodedInputStream:input extensionRegistry:extensionRegistry];
if (errorPtr) {
*errorPtr = nil;
}
}
@catch (NSException *exception) {
[self release];
self = nil;
if (errorPtr) {
*errorPtr = MessageErrorWithReason(GPBMessageErrorCodeMalformedData,
exception.reason);
}
}
#ifdef DEBUG
if (self && !self.initialized) {
[self release];
self = nil;
if (errorPtr) {
*errorPtr = MessageError(GPBMessageErrorCodeMissingRequiredField, nil);
}
}
#endif
}
return self;
}
- (void)dealloc {
[self internalClear:NO];
NSCAssert(!autocreator_, @"Autocreator was not cleared before dealloc.");
if (readOnlySemaphore_) {
dispatch_release(readOnlySemaphore_);
}
[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 (GPBFieldDataTypeIsMessage(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.mapKeyDataType == GPBDataTypeString) {
// 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 (GPBFieldDataTypeIsObject(field)) {
// NSArray
newValue = [value mutableCopyWithZone:zone];
} else {
// GPB*Array
newValue = [value copyWithZone:zone];
}
} else {
if (field.mapKeyDataType == GPBDataTypeString) {
// 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 (GPBFieldDataTypeIsMessage(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 (GPBFieldDataTypeIsObject(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 primitive 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 (GPBFieldDataTypeIsObject(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;
}
}
} else {
if ((field.mapKeyDataType == GPBDataTypeString) &&
GPBFieldDataTypeIsObject(field)) {
GPBAutocreatedDictionary *autoDict = arrayOrMap;
if (autoDict->_autocreator == self) {
autoDict->_autocreator = nil;
}
} else {
// Type doesn't matter, it is a GPB*Dictionary.
GPBInt32Int32Dictionary *gpbDict = arrayOrMap;
if (gpbDict->_autocreator == self) {
gpbDict->_autocreator = nil;
}
}
}
[arrayOrMap release];
}
} else if (GPBFieldDataTypeIsMessage(field)) {
GPBClearAutocreatedMessageIvarWithField(self, field);
GPBMessage *value = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
[value release];
} else if (GPBFieldDataTypeIsObject(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 (GPBFieldDataTypeIsMessage(field)) {
GPBFieldType fieldType = field.fieldType;
if (fieldType == GPBFieldTypeSingle) {
if (field.isRequired) {
GPBMessage *message = GPBGetMessageMessageField(self, field);
if (!message.initialized) {
return NO;
}
} else {
NSAssert(field.isOptional,
@"%@: Single message field %@ not required or optional?",
[self class], field.name);
if (GPBGetHasIvarField(self, field)) {
GPBMessage *message = GPBGetMessageMessageField(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.mapKeyDataType == GPBDataTypeString) {
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:^(GPBExtensionDescriptor *extension,
id obj,
BOOL *stop) {
if (GPBExtensionIsMessage(extension)) {
if (extension.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 {
#ifdef DEBUG
if (!self.initialized) {
return nil;
}
#endif
NSMutableData *data = [NSMutableData dataWithLength:[self serializedSize]];
GPBCodedOutputStream *stream =
[[GPBCodedOutputStream alloc] initWithData:data];
@try {
[self writeToCodedOutputStream:stream];
}
@catch (NSException *exception) {
// This really shouldn't happen. The only way writeToCodedOutputStream:
// could throw is if something in the library has a bug and the
// serializedSize was wrong.
#ifdef DEBUG
NSLog(@"%@: Internal exception while building message data: %@",
[self class], exception);
#endif
data = nil;
}
[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];
@try {
[self writeDelimitedToCodedOutputStream:stream];
}
@catch (NSException *exception) {
// This really shouldn't happen. The only way writeToCodedOutputStream:
// could throw is if something in the library has a bug and the
// serializedSize was wrong.
#ifdef DEBUG
NSLog(@"%@: Internal exception while building message delimitedData: %@",
[self class], exception);
#endif
// If it happens, truncate.
data.length = 0;
}
[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 GPBDataType##TYPE:
//% if (fieldType == GPBFieldTypeRepeated) {
//% uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
//% GPB##ARRAY_TYPE##Array *array =
//% GPBGetObjectIvarWithFieldNoAutocreate(self, field);
//% [output write##TYPE##Array:fieldNumber values:array tag:tag];
//% } else if (fieldType == GPBFieldTypeSingle) {
//% [output write##TYPE:fieldNumber
//% TYPE$S value:GPBGetMessage##REAL_TYPE##Field(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 GPBDataType##TYPE:
//% if (fieldType == GPBFieldTypeRepeated) {
//% NSArray *array = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
//% [output write##TYPE##Array: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);
//% GPBDataType mapKeyDataType = field.mapKeyDataType;
//% if (mapKeyDataType == GPBDataTypeString) {
//% GPBDictionaryWriteToStreamInternalHelper(output, dict, field);
//% } else {
//% [dict writeToCodedOutputStream:output asField:field];
//% }
//% }
//% break;
//%
switch (GPBGetFieldDataType(field)) {
//%PDDM-EXPAND FIELD_CASE(Bool, Bool)
// This block of code is generated, do not edit it directly.
case GPBDataTypeBool:
if (fieldType == GPBFieldTypeRepeated) {
uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
GPBBoolArray *array =
GPBGetObjectIvarWithFieldNoAutocreate(self, field);
[output writeBoolArray:fieldNumber values:array tag:tag];
} else if (fieldType == GPBFieldTypeSingle) {
[output writeBool:fieldNumber
value:GPBGetMessageBoolField(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 GPBDataTypeFixed32:
if (fieldType == GPBFieldTypeRepeated) {
uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
GPBUInt32Array *array =
GPBGetObjectIvarWithFieldNoAutocreate(self, field);
[output writeFixed32Array:fieldNumber values:array tag:tag];
} else if (fieldType == GPBFieldTypeSingle) {
[output writeFixed32:fieldNumber
value:GPBGetMessageUInt32Field(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 GPBDataTypeSFixed32:
if (fieldType == GPBFieldTypeRepeated) {
uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
GPBInt32Array *array =
GPBGetObjectIvarWithFieldNoAutocreate(self, field);
[output writeSFixed32Array:fieldNumber values:array tag:tag];
} else if (fieldType == GPBFieldTypeSingle) {
[output writeSFixed32:fieldNumber
value:GPBGetMessageInt32Field(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 GPBDataTypeFloat:
if (fieldType == GPBFieldTypeRepeated) {
uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
GPBFloatArray *array =
GPBGetObjectIvarWithFieldNoAutocreate(self, field);
[output writeFloatArray:fieldNumber values:array tag:tag];
} else if (fieldType == GPBFieldTypeSingle) {
[output writeFloat:fieldNumber
value:GPBGetMessageFloatField(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 GPBDataTypeFixed64:
if (fieldType == GPBFieldTypeRepeated) {
uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
GPBUInt64Array *array =
GPBGetObjectIvarWithFieldNoAutocreate(self, field);
[output writeFixed64Array:fieldNumber values:array tag:tag];
} else if (fieldType == GPBFieldTypeSingle) {
[output writeFixed64:fieldNumber
value:GPBGetMessageUInt64Field(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 GPBDataTypeSFixed64:
if (fieldType == GPBFieldTypeRepeated) {
uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
GPBInt64Array *array =
GPBGetObjectIvarWithFieldNoAutocreate(self, field);
[output writeSFixed64Array:fieldNumber values:array tag:tag];
} else if (fieldType == GPBFieldTypeSingle) {
[output writeSFixed64:fieldNumber
value:GPBGetMessageInt64Field(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 GPBDataTypeDouble:
if (fieldType == GPBFieldTypeRepeated) {
uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
GPBDoubleArray *array =
GPBGetObjectIvarWithFieldNoAutocreate(self, field);
[output writeDoubleArray:fieldNumber values:array tag:tag];
} else if (fieldType == GPBFieldTypeSingle) {
[output writeDouble:fieldNumber
value:GPBGetMessageDoubleField(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 GPBDataTypeInt32:
if (fieldType == GPBFieldTypeRepeated) {
uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
GPBInt32Array *array =
GPBGetObjectIvarWithFieldNoAutocreate(self, field);
[output writeInt32Array:fieldNumber values:array tag:tag];
} else if (fieldType == GPBFieldTypeSingle) {
[output writeInt32:fieldNumber
value:GPBGetMessageInt32Field(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 GPBDataTypeInt64:
if (fieldType == GPBFieldTypeRepeated) {
uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
GPBInt64Array *array =
GPBGetObjectIvarWithFieldNoAutocreate(self, field);
[output writeInt64Array:fieldNumber values:array tag:tag];
} else if (fieldType == GPBFieldTypeSingle) {
[output writeInt64:fieldNumber
value:GPBGetMessageInt64Field(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 GPBDataTypeSInt32:
if (fieldType == GPBFieldTypeRepeated) {
uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
GPBInt32Array *array =
GPBGetObjectIvarWithFieldNoAutocreate(self, field);
[output writeSInt32Array:fieldNumber values:array tag:tag];
} else if (fieldType == GPBFieldTypeSingle) {
[output writeSInt32:fieldNumber
value:GPBGetMessageInt32Field(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 GPBDataTypeSInt64:
if (fieldType == GPBFieldTypeRepeated) {
uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
GPBInt64Array *array =
GPBGetObjectIvarWithFieldNoAutocreate(self, field);
[output writeSInt64Array:fieldNumber values:array tag:tag];
} else if (fieldType == GPBFieldTypeSingle) {
[output writeSInt64:fieldNumber
value:GPBGetMessageInt64Field(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 GPBDataTypeUInt32:
if (fieldType == GPBFieldTypeRepeated) {
uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
GPBUInt32Array *array =
GPBGetObjectIvarWithFieldNoAutocreate(self, field);
[output writeUInt32Array:fieldNumber values:array tag:tag];
} else if (fieldType == GPBFieldTypeSingle) {
[output writeUInt32:fieldNumber
value:GPBGetMessageUInt32Field(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 GPBDataTypeUInt64:
if (fieldType == GPBFieldTypeRepeated) {
uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
GPBUInt64Array *array =
GPBGetObjectIvarWithFieldNoAutocreate(self, field);
[output writeUInt64Array:fieldNumber values:array tag:tag];
} else if (fieldType == GPBFieldTypeSingle) {
[output writeUInt64:fieldNumber
value:GPBGetMessageUInt64Field(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 GPBDataTypeEnum:
if (fieldType == GPBFieldTypeRepeated) {
uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
GPBEnumArray *array =
GPBGetObjectIvarWithFieldNoAutocreate(self, field);
[output writeEnumArray:fieldNumber values:array tag:tag];
} else if (fieldType == GPBFieldTypeSingle) {
[output writeEnum:fieldNumber
value:GPBGetMessageInt32Field(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(Bytes)
// This block of code is generated, do not edit it directly.
case GPBDataTypeBytes:
if (fieldType == GPBFieldTypeRepeated) {
NSArray *array = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
[output writeBytesArray:fieldNumber values:array];
} else if (fieldType == GPBFieldTypeSingle) {
// GPBGetObjectIvarWithFieldNoAutocreate() avoids doing the has check
// again.
[output writeBytes:fieldNumber
value:GPBGetObjectIvarWithFieldNoAutocreate(self, field)];
} else { // fieldType == GPBFieldTypeMap
// Exact type here doesn't matter.
id dict = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
GPBDataType mapKeyDataType = field.mapKeyDataType;
if (mapKeyDataType == GPBDataTypeString) {
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 GPBDataTypeString:
if (fieldType == GPBFieldTypeRepeated) {
NSArray *array = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
[output writeStringArray: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);
GPBDataType mapKeyDataType = field.mapKeyDataType;
if (mapKeyDataType == GPBDataTypeString) {
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 GPBDataTypeMessage:
if (fieldType == GPBFieldTypeRepeated) {
NSArray *array = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
[output writeMessageArray: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);
GPBDataType mapKeyDataType = field.mapKeyDataType;
if (mapKeyDataType == GPBDataTypeString) {
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 GPBDataTypeGroup:
if (fieldType == GPBFieldTypeRepeated) {
NSArray *array = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
[output writeGroupArray: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);
GPBDataType mapKeyDataType = field.mapKeyDataType;
if (mapKeyDataType == GPBDataTypeString) {
GPBDictionaryWriteToStreamInternalHelper(output, dict, field);
} else {
[dict writeToCodedOutputStream:output asField:field];
}
}
break;
//%PDDM-EXPAND-END (18 expansions)
}
}
#pragma mark - Extensions
- (id)getExtension:(GPBExtensionDescriptor *)extension {
CheckExtension(self, extension);
id value = [extensionMap_ objectForKey:extension];
if (value != nil) {
return value;
}
// No default for repeated.
if (extension.isRepeated) {
return nil;
}
// Non messages get their default.
if (!GPBExtensionIsMessage(extension)) {
return extension.defaultValue;
}
// Check for an autocreated value.
GPBPrepareReadOnlySemaphore(self);
dispatch_semaphore_wait(readOnlySemaphore_, DISPATCH_TIME_FOREVER);
value = [autocreatedExtensionMap_ objectForKey:extension];
if (!value) {
// Auto create the message extensions to match normal fields.
value = CreateMessageWithAutocreatorForExtension(extension.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];
}
dispatch_semaphore_signal(readOnlySemaphore_);
return value;
}
- (id)getExistingExtension:(GPBExtensionDescriptor *)extension {
// This is an internal method so we don't need to call CheckExtension().
return [extensionMap_ objectForKey:extension];
}
- (BOOL)hasExtension:(GPBExtensionDescriptor *)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 (GPBExtensionDescriptor *extension in sortedExtensions) {
uint32_t fieldNumber = extension.fieldNumber;
if (fieldNumber >= start && fieldNumber < end) {
id value = [extensionMap_ objectForKey:extension];
GPBWriteExtensionValueToOutputStream(extension, value, output);
}
}
}
- (NSArray *)sortedExtensionsInUse {
return [[extensionMap_ allKeys]
sortedArrayUsingSelector:@selector(compareByFieldNumber:)];
}
- (void)setExtension:(GPBExtensionDescriptor *)extension value:(id)value {
if (!value) {
[self clearExtension:extension];
return;
}
CheckExtension(self, extension);
if (extension.repeated) {
[NSException raise:NSInvalidArgumentException
format:@"Must call addExtension() for repeated types."];
}
if (extensionMap_ == nil) {
extensionMap_ = [[NSMutableDictionary alloc] init];
}
// This pointless cast is for CLANG_WARN_NULLABLE_TO_NONNULL_CONVERSION.
// Without it, the compiler complains we're passing an id nullable when
// setObject:forKey: requires a id nonnull for the value. The check for
// !value at the start of the method ensures it isn't nil, but the check
// isn't smart enough to realize that.
[extensionMap_ setObject:(id)value forKey:extension];
GPBExtensionDescriptor *descriptor = extension;
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:(GPBExtensionDescriptor *)extension value:(id)value {
CheckExtension(self, extension);
if (!extension.repeated) {
[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:(GPBExtensionDescriptor *)extension
index:(NSUInteger)idx
value:(id)value {
CheckExtension(self, extension);
if (!extension.repeated) {
[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:(GPBExtensionDescriptor *)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 = GPBCodedInputStreamReadRetainedBytesNoCopy(state);
if (data == nil) {
return;
}
[self mergeFromData:data extensionRegistry:extensionRegistry];
[data release];
}
#pragma mark - Parse From Data Support
+ (instancetype)parseFromData:(NSData *)data error:(NSError **)errorPtr {
return [self parseFromData:data extensionRegistry:nil error:errorPtr];
}
+ (instancetype)parseFromData:(NSData *)data
extensionRegistry:(GPBExtensionRegistry *)extensionRegistry
error:(NSError **)errorPtr {
return [[[self alloc] initWithData:data
extensionRegistry:extensionRegistry
error:errorPtr] autorelease];
}
+ (instancetype)parseFromCodedInputStream:(GPBCodedInputStream *)input
extensionRegistry:(GPBExtensionRegistry *)extensionRegistry
error:(NSError **)errorPtr {
return
[[[self alloc] initWithCodedInputStream:input
extensionRegistry:extensionRegistry
error:errorPtr] autorelease];
}
#pragma mark - Parse Delimited From Data Support
+ (instancetype)parseDelimitedFromCodedInputStream:(GPBCodedInputStream *)input
extensionRegistry:
(GPBExtensionRegistry *)extensionRegistry
error:(NSError **)errorPtr {
GPBMessage *message = [[[self alloc] init] autorelease];
@try {
[message mergeDelimitedFromCodedInputStream:input
extensionRegistry:extensionRegistry];
if (errorPtr) {
*errorPtr = nil;
}
}
@catch (NSException *exception) {
message = nil;
if (errorPtr) {
*errorPtr = MessageErrorWithReason(GPBMessageErrorCodeMalformedData,
exception.reason);
}
}
#ifdef DEBUG
if (message && !message.initialized) {
message = nil;
if (errorPtr) {
*errorPtr = MessageError(GPBMessageErrorCodeMissingRequiredField, nil);
}
}
#endif
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;
GPBExtensionDescriptor *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 extensionForDescriptor:[self descriptor]
fieldNumber:typeId];
}
} else if (tag == GPBWireFormatMessageSetMessageTag) {
rawBytes =
[GPBCodedInputStreamReadRetainedBytesNoCopy(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];
GPBExtensionMergeFromInputStream(extension,
extension.packable,
newInput,
extensionRegistry,
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];
GPBExtensionDescriptor *extension =
[extensionRegistry extensionForDescriptor:descriptor
fieldNumber:fieldNumber];
if (extension == nil) {
if (descriptor.wireFormat && GPBWireFormatMessageSetItemTag == tag) {
[self parseMessageSet:input extensionRegistry:extensionRegistry];
return YES;
}
} else {
if (extension.wireType == wireType) {
GPBExtensionMergeFromInputStream(extension,
extension.packable,
input,
extensionRegistry,
self);
return YES;
}
// Primitive, repeated types can be packed on unpacked on the wire, and are
// parsed either way.
if ([extension isRepeated] &&
!GPBDataTypeIsObject(extension->description_->dataType) &&
(extension.alternateWireType == wireType)) {
GPBExtensionMergeFromInputStream(extension,
!extension.packable,
input,
extensionRegistry,
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
static void MergeSingleFieldFromCodedInputStream(
GPBMessage *self, GPBFieldDescriptor *field, GPBFileSyntax syntax,
GPBCodedInputStream *input, GPBExtensionRegistry *extensionRegistry) {
GPBDataType fieldDataType = GPBGetFieldDataType(field);
switch (fieldDataType) {
#define CASE_SINGLE_POD(NAME, TYPE, FUNC_TYPE) \
case GPBDataType##NAME: { \
TYPE val = GPBCodedInputStreamRead##NAME(&input->state_); \
GPBSet##FUNC_TYPE##IvarWithFieldInternal(self, field, val, syntax); \
break; \
}
#define CASE_SINGLE_OBJECT(NAME) \
case GPBDataType##NAME: { \
id val = GPBCodedInputStreamReadRetained##NAME(&input->state_); \
GPBSetRetainedObjectIvarWithFieldInternal(self, field, val, syntax); \
break; \
}
CASE_SINGLE_POD(Bool, BOOL, Bool)
CASE_SINGLE_POD(Fixed32, uint32_t, UInt32)
CASE_SINGLE_POD(SFixed32, int32_t, Int32)
CASE_SINGLE_POD(Float, float, Float)
CASE_SINGLE_POD(Fixed64, uint64_t, UInt64)
CASE_SINGLE_POD(SFixed64, int64_t, Int64)
CASE_SINGLE_POD(Double, double, Double)
CASE_SINGLE_POD(Int32, int32_t, Int32)
CASE_SINGLE_POD(Int64, int64_t, Int64)
CASE_SINGLE_POD(SInt32, int32_t, Int32)
CASE_SINGLE_POD(SInt64, int64_t, Int64)
CASE_SINGLE_POD(UInt32, uint32_t, UInt32)
CASE_SINGLE_POD(UInt64, uint64_t, UInt64)
CASE_SINGLE_OBJECT(Bytes)
CASE_SINGLE_OBJECT(String)
#undef CASE_SINGLE_POD
#undef CASE_SINGLE_OBJECT
case GPBDataTypeMessage: {
if (GPBGetHasIvarField(self, field)) {
// GPBGetObjectIvarWithFieldNoAutocreate() avoids doing the has
// check again.
GPBMessage *message =
GPBGetObjectIvarWithFieldNoAutocreate(self, field);
[input readMessage:message extensionRegistry:extensionRegistry];
} else {
GPBMessage *message = [[field.msgClass alloc] init];
[input readMessage:message extensionRegistry:extensionRegistry];
GPBSetRetainedObjectIvarWithFieldInternal(self, field, message, syntax);
}
break;
}
case GPBDataTypeGroup: {
if (GPBGetHasIvarField(self, field)) {
// GPBGetObjectIvarWithFieldNoAutocreate() avoids doing the has
// check again.
GPBMessage *message =
GPBGetObjectIvarWithFieldNoAutocreate(self, field);
[input readGroup:GPBFieldNumber(field)
message:message
extensionRegistry:extensionRegistry];
} else {
GPBMessage *message = [[field.msgClass alloc] init];
[input readGroup:GPBFieldNumber(field)
message:message
extensionRegistry:extensionRegistry];
GPBSetRetainedObjectIvarWithFieldInternal(self, field, message, syntax);
}
break;
}
case GPBDataTypeEnum: {
int32_t val = GPBCodedInputStreamReadEnum(&input->state_);
if (GPBHasPreservingUnknownEnumSemantics(syntax) ||
[field isValidEnumValue:val]) {
GPBSetInt32IvarWithFieldInternal(self, field, val, syntax);
} else {
GPBUnknownFieldSet *unknownFields = GetOrMakeUnknownFields(self);
[unknownFields mergeVarintField:GPBFieldNumber(field) value:val];
}
}
} // switch
}
static void MergeRepeatedPackedFieldFromCodedInputStream(
GPBMessage *self, GPBFieldDescriptor *field, GPBFileSyntax syntax,
GPBCodedInputStream *input) {
GPBDataType fieldDataType = GPBGetFieldDataType(field);
GPBCodedInputStreamState *state = &input->state_;
id genericArray = GetOrCreateArrayIvarWithField(self, field, syntax);
int32_t length = GPBCodedInputStreamReadInt32(state);
size_t limit = GPBCodedInputStreamPushLimit(state, length);
while (GPBCodedInputStreamBytesUntilLimit(state) > 0) {
switch (fieldDataType) {
#define CASE_REPEATED_PACKED_POD(NAME, TYPE, ARRAY_TYPE) \
case GPBDataType##NAME: { \
TYPE val = GPBCodedInputStreamRead##NAME(state); \
[(GPB##ARRAY_TYPE##Array *)genericArray addValue:val]; \
break; \
}
CASE_REPEATED_PACKED_POD(Bool, BOOL, Bool)
CASE_REPEATED_PACKED_POD(Fixed32, uint32_t, UInt32)
CASE_REPEATED_PACKED_POD(SFixed32, int32_t, Int32)
CASE_REPEATED_PACKED_POD(Float, float, Float)
CASE_REPEATED_PACKED_POD(Fixed64, uint64_t, UInt64)
CASE_REPEATED_PACKED_POD(SFixed64, int64_t, Int64)
CASE_REPEATED_PACKED_POD(Double, double, Double)
CASE_REPEATED_PACKED_POD(Int32, int32_t, Int32)
CASE_REPEATED_PACKED_POD(Int64, int64_t, Int64)
CASE_REPEATED_PACKED_POD(SInt32, int32_t, Int32)
CASE_REPEATED_PACKED_POD(SInt64, int64_t, Int64)
CASE_REPEATED_PACKED_POD(UInt32, uint32_t, UInt32)
CASE_REPEATED_PACKED_POD(UInt64, uint64_t, UInt64)
#undef CASE_REPEATED_PACKED_POD
case GPBDataTypeBytes:
case GPBDataTypeString:
case GPBDataTypeMessage:
case GPBDataTypeGroup:
NSCAssert(NO, @"Non primitive types can't be packed");
break;
case GPBDataTypeEnum: {
int32_t val = GPBCodedInputStreamReadEnum(state);
if (GPBHasPreservingUnknownEnumSemantics(syntax) ||
[field isValidEnumValue:val]) {
[(GPBEnumArray*)genericArray addRawValue:val];
} else {
GPBUnknownFieldSet *unknownFields = GetOrMakeUnknownFields(self);
[unknownFields mergeVarintField:GPBFieldNumber(field) value:val];
}
break;
}
} // switch
} // while(BytesUntilLimit() > 0)
GPBCodedInputStreamPopLimit(state, limit);
}
static void MergeRepeatedNotPackedFieldFromCodedInputStream(
GPBMessage *self, GPBFieldDescriptor *field, GPBFileSyntax syntax,
GPBCodedInputStream *input, GPBExtensionRegistry *extensionRegistry) {
GPBCodedInputStreamState *state = &input->state_;
id genericArray = GetOrCreateArrayIvarWithField(self, field, syntax);
switch (GPBGetFieldDataType(field)) {
#define CASE_REPEATED_NOT_PACKED_POD(NAME, TYPE, ARRAY_TYPE) \
case GPBDataType##NAME: { \
TYPE val = GPBCodedInputStreamRead##NAME(state); \
[(GPB##ARRAY_TYPE##Array *)genericArray addValue:val]; \
break; \
}
#define CASE_REPEATED_NOT_PACKED_OBJECT(NAME) \
case GPBDataType##NAME: { \
id val = GPBCodedInputStreamReadRetained##NAME(state); \
[(NSMutableArray*)genericArray addObject:val]; \
[val release]; \
break; \
}
CASE_REPEATED_NOT_PACKED_POD(Bool, BOOL, Bool)
CASE_REPEATED_NOT_PACKED_POD(Fixed32, uint32_t, UInt32)
CASE_REPEATED_NOT_PACKED_POD(SFixed32, int32_t, Int32)
CASE_REPEATED_NOT_PACKED_POD(Float, float, Float)
CASE_REPEATED_NOT_PACKED_POD(Fixed64, uint64_t, UInt64)
CASE_REPEATED_NOT_PACKED_POD(SFixed64, int64_t, Int64)
CASE_REPEATED_NOT_PACKED_POD(Double, double, Double)
CASE_REPEATED_NOT_PACKED_POD(Int32, int32_t, Int32)
CASE_REPEATED_NOT_PACKED_POD(Int64, int64_t, Int64)
CASE_REPEATED_NOT_PACKED_POD(SInt32, int32_t, Int32)
CASE_REPEATED_NOT_PACKED_POD(SInt64, int64_t, Int64)
CASE_REPEATED_NOT_PACKED_POD(UInt32, uint32_t, UInt32)
CASE_REPEATED_NOT_PACKED_POD(UInt64, uint64_t, UInt64)
CASE_REPEATED_NOT_PACKED_OBJECT(Bytes)
CASE_REPEATED_NOT_PACKED_OBJECT(String)
#undef CASE_REPEATED_NOT_PACKED_POD
#undef CASE_NOT_PACKED_OBJECT
case GPBDataTypeMessage: {
GPBMessage *message = [[field.msgClass alloc] init];
[input readMessage:message extensionRegistry:extensionRegistry];
[(NSMutableArray*)genericArray addObject:message];
[message release];
break;
}
case GPBDataTypeGroup: {
GPBMessage *message = [[field.msgClass alloc] init];
[input readGroup:GPBFieldNumber(field)
message:message
extensionRegistry:extensionRegistry];
[(NSMutableArray*)genericArray addObject:message];
[message release];
break;
}
case GPBDataTypeEnum: {
int32_t val = GPBCodedInputStreamReadEnum(state);
if (GPBHasPreservingUnknownEnumSemantics(syntax) ||
[field isValidEnumValue:val]) {
[(GPBEnumArray*)genericArray addRawValue:val];
} else {
GPBUnknownFieldSet *unknownFields = GetOrMakeUnknownFields(self);
[unknownFields mergeVarintField:GPBFieldNumber(field) value:val];
}
break;
}
} // switch
}
- (void)mergeFromCodedInputStream:(GPBCodedInputStream *)input
extensionRegistry:(GPBExtensionRegistry *)extensionRegistry {
GPBDescriptor *descriptor = [self descriptor];
GPBFileSyntax syntax = descriptor.file.syntax;
GPBCodedInputStreamState *state = &input->state_;
uint32_t tag = 0;
NSUInteger startingIndex = 0;
NSArray *fields = descriptor->fields_;
NSUInteger numFields = fields.count;
while (YES) {
BOOL merged = NO;
tag = GPBCodedInputStreamReadTag(state);
for (NSUInteger i = 0; i < numFields; ++i) {
if (startingIndex >= numFields) startingIndex = 0;
GPBFieldDescriptor *fieldDescriptor = fields[startingIndex];
if (GPBFieldTag(fieldDescriptor) == tag) {
GPBFieldType fieldType = fieldDescriptor.fieldType;
if (fieldType == GPBFieldTypeSingle) {
MergeSingleFieldFromCodedInputStream(self, fieldDescriptor, syntax,
input, extensionRegistry);
// Well formed protos will only have a single field once, advance
// the starting index to the next field.
startingIndex += 1;
} else if (fieldType == GPBFieldTypeRepeated) {
if (fieldDescriptor.isPackable) {
MergeRepeatedPackedFieldFromCodedInputStream(
self, fieldDescriptor, syntax, input);
// Well formed protos will only have a repeated field that is
// packed once, advance the starting index to the next field.
startingIndex += 1;
} else {
MergeRepeatedNotPackedFieldFromCodedInputStream(
self, fieldDescriptor, syntax, input, extensionRegistry);
}
} else { // fieldType == GPBFieldTypeMap
// GPB*Dictionary or NSDictionary, exact type doesn't matter at this
// point.
id map = GetOrCreateMapIvarWithField(self, fieldDescriptor, syntax);
[input readMapEntry:map
extensionRegistry:extensionRegistry
field:fieldDescriptor
parentMessage:self];
}
merged = YES;
break;
} else {
startingIndex += 1;
}
} // for(i < numFields)
if (!merged) {
// Primitive, repeated types can be packed on unpacked on the wire, and
// are parsed either way. The above loop covered tag in the preferred
// for, so this need to check the alternate form.
for (NSUInteger i = 0; i < numFields; ++i) {
if (startingIndex >= numFields) startingIndex = 0;
GPBFieldDescriptor *fieldDescriptor = fields[startingIndex];
if ((fieldDescriptor.fieldType == GPBFieldTypeRepeated) &&
!GPBFieldDataTypeIsObject(fieldDescriptor) &&
(GPBFieldAlternateTag(fieldDescriptor) == tag)) {
BOOL alternateIsPacked = !fieldDescriptor.isPackable;
if (alternateIsPacked) {
MergeRepeatedPackedFieldFromCodedInputStream(
self, fieldDescriptor, syntax, input);
// Well formed protos will only have a repeated field that is
// packed once, advance the starting index to the next field.
startingIndex += 1;
} else {
MergeRepeatedNotPackedFieldFromCodedInputStream(
self, fieldDescriptor, syntax, input, extensionRegistry);
}
merged = YES;
break;
} else {
startingIndex += 1;
}
}
}
if (!merged) {
if (tag == 0) {
// zero signals EOF / limit reached
return;
} else {
if (GPBPreserveUnknownFields(syntax)) {
if (![self parseUnknownField:input
extensionRegistry:extensionRegistry
tag:tag]) {
// it's an endgroup tag
return;
}
} else {
if (![input skipField:tag]) {
return;
}
}
}
} // if(!merged)
} // while(YES)
}
#pragma mark - MergeFrom Support
- (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];
}
// We assume something will be done and become visible.
GPBBecomeVisibleToAutocreator(self);
GPBDescriptor *descriptor = [[self class] descriptor];
GPBFileSyntax syntax = descriptor.file.syntax;
for (GPBFieldDescriptor *field in descriptor->fields_) {
GPBFieldType fieldType = field.fieldType;
if (fieldType == GPBFieldTypeSingle) {
int32_t hasIndex = GPBFieldHasIndex(field);
uint32_t fieldNumber = GPBFieldNumber(field);
if (!GPBGetHasIvar(other, hasIndex, fieldNumber)) {
// Other doesn't have the field set, on to the next.
continue;
}
GPBDataType fieldDataType = GPBGetFieldDataType(field);
switch (fieldDataType) {
case GPBDataTypeBool:
GPBSetBoolIvarWithFieldInternal(
self, field, GPBGetMessageBoolField(other, field), syntax);
break;
case GPBDataTypeSFixed32:
case GPBDataTypeEnum:
case GPBDataTypeInt32:
case GPBDataTypeSInt32:
GPBSetInt32IvarWithFieldInternal(
self, field, GPBGetMessageInt32Field(other, field), syntax);
break;
case GPBDataTypeFixed32:
case GPBDataTypeUInt32:
GPBSetUInt32IvarWithFieldInternal(
self, field, GPBGetMessageUInt32Field(other, field), syntax);
break;
case GPBDataTypeSFixed64:
case GPBDataTypeInt64:
case GPBDataTypeSInt64:
GPBSetInt64IvarWithFieldInternal(
self, field, GPBGetMessageInt64Field(other, field), syntax);
break;
case GPBDataTypeFixed64:
case GPBDataTypeUInt64:
GPBSetUInt64IvarWithFieldInternal(
self, field, GPBGetMessageUInt64Field(other, field), syntax);
break;
case GPBDataTypeFloat:
GPBSetFloatIvarWithFieldInternal(
self, field, GPBGetMessageFloatField(other, field), syntax);
break;
case GPBDataTypeDouble:
GPBSetDoubleIvarWithFieldInternal(
self, field, GPBGetMessageDoubleField(other, field), syntax);
break;
case GPBDataTypeBytes:
case GPBDataTypeString: {
id otherVal = GPBGetObjectIvarWithFieldNoAutocreate(other, field);
GPBSetObjectIvarWithFieldInternal(self, field, otherVal, syntax);
break;
}
case GPBDataTypeMessage:
case GPBDataTypeGroup: {
id otherVal = GPBGetObjectIvarWithFieldNoAutocreate(other, field);
if (GPBGetHasIvar(self, hasIndex, fieldNumber)) {
GPBMessage *message =
GPBGetObjectIvarWithFieldNoAutocreate(self, field);
[message mergeFrom:otherVal];
} else {
GPBMessage *message = [otherVal copy];
GPBSetRetainedObjectIvarWithFieldInternal(self, field, message,
syntax);
}
break;
}
} // switch()
} else 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(other, field);
if (otherArray) {
GPBDataType fieldDataType = field->description_->dataType;
if (GPBDataTypeIsObject(fieldDataType)) {
NSMutableArray *resultArray =
GetOrCreateArrayIvarWithField(self, field, syntax);
[resultArray addObjectsFromArray:otherArray];
} else if (fieldDataType == GPBDataTypeEnum) {
GPBEnumArray *resultArray =
GetOrCreateArrayIvarWithField(self, field, syntax);
[resultArray addRawValuesFromArray:otherArray];
} else {
// The array type doesn't matter, that all implment
// -addValuesFromArray:.
GPBInt32Array *resultArray =
GetOrCreateArrayIvarWithField(self, field, syntax);
[resultArray addValuesFromArray:otherArray];
}
}
} else { // 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(other, field);
if (otherDict) {
GPBDataType keyDataType = field.mapKeyDataType;
GPBDataType valueDataType = field->description_->dataType;
if (GPBDataTypeIsObject(keyDataType) &&
GPBDataTypeIsObject(valueDataType)) {
NSMutableDictionary *resultDict =
GetOrCreateMapIvarWithField(self, field, syntax);
[resultDict addEntriesFromDictionary:otherDict];
} else if (valueDataType == GPBDataTypeEnum) {
// The exact type doesn't matter, just need to know it is a
// GPB*EnumDictionary.
GPBInt32EnumDictionary *resultDict =
GetOrCreateMapIvarWithField(self, field, syntax);
[resultDict addRawEntriesFromDictionary:otherDict];
} else {
// The exact type doesn't matter, they all implement
// -addEntriesFromDictionary:.
GPBInt32Int32Dictionary *resultDict =
GetOrCreateMapIvarWithField(self, field, syntax);
[resultDict addEntriesFromDictionary:otherDict];
}
}
} // if (fieldType)..else if...else
} // for(fields)
// Unknown fields.
if (!unknownFields_) {
[self setUnknownFields:other.unknownFields];
} else {
[unknownFields_ mergeUnknownFields:other.unknownFields];
}
// Extensions
if (other->extensionMap_.count == 0) {
return;
}
if (extensionMap_ == nil) {
extensionMap_ =
CloneExtensionMap(other->extensionMap_, NSZoneFromPointer(self));
} else {
for (GPBExtensionDescriptor *extension in other->extensionMap_) {
id otherValue = [other->extensionMap_ objectForKey:extension];
id value = [extensionMap_ objectForKey:extension];
BOOL isMessageExtension = GPBExtensionIsMessage(extension);
if (extension.repeated) {
NSMutableArray *list = value;
if (list == nil) {
list = [[NSMutableArray alloc] init];
[extensionMap_ setObject:list forKey:extension];
[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:extension];
[copiedValue release];
}
} else {
[extensionMap_ setObject:otherValue forKey:extension];
}
}
if (isMessageExtension && !extension.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];
}
}
}
}
#pragma mark - isEqual: & hash Support
- (BOOL)isEqual:(GPBMessage *)other {
if (other == self) {
return YES;
}
if (![other isKindOfClass:[self class]] &&
![self isKindOfClass:[other class]]) {
return NO;
}
GPBDescriptor *descriptor = [[self class] descriptor];
uint8_t *selfStorage = (uint8_t *)messageStorage_;
uint8_t *otherStorage = (uint8_t *)other->messageStorage_;
for (GPBFieldDescriptor *field in descriptor->fields_) {
if (GPBFieldIsMapOrArray(field)) {
// In the case of a list or map, there is no _hasIvar to worry about.
// NOTE: These are NSArray/GPB*Array or NSDictionary/GPB*Dictionary, but
// the type doesn't really matter as the objects all support -count and
// -isEqual:.
NSArray *resultMapOrArray =
GPBGetObjectIvarWithFieldNoAutocreate(self, field);
NSArray *otherMapOrArray =
GPBGetObjectIvarWithFieldNoAutocreate(other, field);
// nil and empty are equal
if (resultMapOrArray.count != 0 || otherMapOrArray.count != 0) {
if (![resultMapOrArray isEqual:otherMapOrArray]) {
return NO;
}
}
} else { // Single field
int32_t hasIndex = GPBFieldHasIndex(field);
uint32_t fieldNum = GPBFieldNumber(field);
BOOL selfHas = GPBGetHasIvar(self, hasIndex, fieldNum);
BOOL otherHas = GPBGetHasIvar(other, hasIndex, fieldNum);
if (selfHas != otherHas) {
return NO; // Differing has values, not equal.
}