Automated rollback of commit 1f717248b7.

PiperOrigin-RevId: 656120088
pull/17623/head
Thomas Van Lenten 8 months ago committed by Copybara-Service
parent a98c7f79aa
commit 1e6abadc2b
  1. 5
      conformance/failure_list_objc.txt
  2. 459
      objectivec/GPBMessage.m
  3. 14
      objectivec/GPBUnknownFieldSet.m
  4. 4
      objectivec/GPBUnknownFieldSet_PackagePrivate.h

@ -1,2 +1,7 @@
# JSON input or output tests are skipped (in conformance_objc.m) as mobile
# platforms don't support JSON wire format to avoid code bloat.
Required.Editions_Proto2.ProtobufInput.UnknownOrdering.ProtobufOutput # Unknown field mismatch
Required.Editions_Proto3.ProtobufInput.UnknownOrdering.ProtobufOutput # Unknown field mismatch
Required.Proto2.ProtobufInput.UnknownOrdering.ProtobufOutput # Unknown field mismatch
Required.Proto3.ProtobufInput.UnknownOrdering.ProtobufOutput # Unknown field mismatch

@ -5,9 +5,9 @@
// license that can be found in the LICENSE file or at
// https://developers.google.com/open-source/licenses/bsd
#import "GPBMessage.h"
#import <Foundation/Foundation.h>
#import "GPBMessage_PackagePrivate.h"
#import <objc/message.h>
#import <objc/runtime.h>
#import <os/lock.h>
@ -20,18 +20,11 @@
#import "GPBDictionary_PackagePrivate.h"
#import "GPBExtensionInternals.h"
#import "GPBExtensionRegistry.h"
#import "GPBMessage_PackagePrivate.h"
#import "GPBRootObject_PackagePrivate.h"
#import "GPBUnknownField.h"
#import "GPBUnknownFieldSet.h"
#import "GPBUnknownFieldSet_PackagePrivate.h"
#import "GPBUnknownFields_PackagePrivate.h"
#import "GPBUtilities_PackagePrivate.h"
// TODO: Consider using on other functions to reduce bloat when
// some compiler optimizations are enabled.
#define GPB_NOINLINE __attribute__((noinline))
// Returns a new instance that was automatically created by |autocreator| for
// its field |field|.
static GPBMessage *GPBCreateMessageWithAutocreator(Class msgClass, GPBMessage *autocreator,
@ -71,16 +64,7 @@ NSString *const GPBMessageExceptionMessageTooLarge =
@interface GPBMessage () {
@package
// Only one of these two is ever set, GPBUnknownFieldSet is being deprecated and will
// eventually be removed, but because that api support mutation, once the property is
// fetch it must continue to be used so any mutations will be honored in future operations
// on the message.
// Read only operations that access these two/cause things to migration between them should
// be protected with an @synchronized(self) block (that way the code also doesn't have to
// worry about throws).
NSMutableData *unknownFieldData_;
GPBUnknownFieldSet *unknownFields_;
NSMutableDictionary *extensionMap_;
// Readonly access to autocreatedExtensionMap_ is protected via readOnlyLock_.
NSMutableDictionary *autocreatedExtensionMap_;
@ -119,6 +103,7 @@ static id GetOrCreateMapIvarWithField(GPBMessage *self, GPBFieldDescriptor *fiel
static id GetMapIvarWithField(GPBMessage *self, GPBFieldDescriptor *field);
static NSMutableDictionary *CloneExtensionMap(NSDictionary *extensionMap, NSZone *zone)
__attribute__((ns_returns_retained));
static GPBUnknownFieldSet *GetOrMakeUnknownFields(GPBMessage *self);
#if defined(DEBUG) && DEBUG
static NSError *MessageError(NSInteger code, NSDictionary *userInfo) {
@ -148,178 +133,6 @@ static NSError *ErrorFromException(NSException *exception) {
return error;
}
// Helper to encode varints onto the mutable data, the max size need is 10 bytes.
GPB_NOINLINE
static uint8_t *EncodeVarintU64(uint64_t val, uint8_t *ptr) {
do {
uint8_t byte = val & 0x7fU;
val >>= 7;
if (val) byte |= 0x80U;
*(ptr++) = byte;
} while (val);
return ptr;
}
// Helper to encode varints onto the mutable data, the max size need is 5 bytes.
GPB_NOINLINE
static uint8_t *EncodeVarintU32(uint32_t val, uint8_t *ptr) {
do {
uint8_t byte = val & 0x7fU;
val >>= 7;
if (val) byte |= 0x80U;
*(ptr++) = byte;
} while (val);
return ptr;
}
// Helper to encode signed int32 values as varints onto the mutable data, the max size need is 10
// bytes.
GPB_NOINLINE
static uint8_t *EncodeVarintS32(int32_t val, uint8_t *ptr) {
if (val >= 0) {
return EncodeVarintU32((uint32_t)val, ptr);
} else {
// Must sign-extend
int64_t extended = val;
return EncodeVarintU64((uint64_t)extended, ptr);
}
}
GPB_NOINLINE
static void AddUnknownFieldVarint32(GPBMessage *self, uint32_t fieldNumber, int32_t value) {
if (self->unknownFields_) {
[self->unknownFields_ mergeVarintField:fieldNumber value:value];
return;
}
uint8_t buf[20];
uint8_t *ptr = buf;
ptr = EncodeVarintU32(GPBWireFormatMakeTag(fieldNumber, GPBWireFormatVarint), ptr);
ptr = EncodeVarintS32(value, ptr);
if (self->unknownFieldData_ == nil) {
self->unknownFieldData_ = [[NSMutableData alloc] initWithCapacity:ptr - buf];
GPBBecomeVisibleToAutocreator(self);
}
[self->unknownFieldData_ appendBytes:buf length:ptr - buf];
}
GPB_NOINLINE
static void AddUnknownFieldLengthDelimited(GPBMessage *self, uint32_t fieldNumber, NSData *value) {
if (self->unknownFields_) {
[self->unknownFields_ mergeLengthDelimited:fieldNumber value:value];
return;
}
uint8_t buf[20];
uint8_t *ptr = buf;
ptr = EncodeVarintU32(GPBWireFormatMakeTag(fieldNumber, GPBWireFormatLengthDelimited), ptr);
ptr = EncodeVarintU64((uint64_t)value.length, ptr);
if (self->unknownFieldData_ == nil) {
self->unknownFieldData_ = [[NSMutableData alloc] initWithCapacity:(ptr - buf) + value.length];
GPBBecomeVisibleToAutocreator(self);
}
[self->unknownFieldData_ appendBytes:buf length:ptr - buf];
[self->unknownFieldData_ appendData:value];
}
GPB_NOINLINE
static void AddUnknownMessageSetEntry(GPBMessage *self, uint32_t typeId, NSData *value) {
if (self->unknownFields_) {
// Legacy Set does this odd storage for MessageSet.
[self->unknownFields_ mergeLengthDelimited:typeId value:value];
return;
}
uint8_t buf[60];
uint8_t *ptr = buf;
ptr = EncodeVarintU32(GPBWireFormatMessageSetItemTag, ptr);
ptr = EncodeVarintU32(GPBWireFormatMessageSetTypeIdTag, ptr);
ptr = EncodeVarintU32(typeId, ptr);
ptr = EncodeVarintU32(GPBWireFormatMessageSetMessageTag, ptr);
ptr = EncodeVarintU64((uint64_t)value.length, ptr);
uint8_t *split = ptr;
ptr = EncodeVarintU32(GPBWireFormatMessageSetItemEndTag, ptr);
uint8_t *end = ptr;
if (self->unknownFieldData_ == nil) {
self->unknownFieldData_ = [[NSMutableData alloc] initWithCapacity:(end - buf) + value.length];
GPBBecomeVisibleToAutocreator(self);
}
[self->unknownFieldData_ appendBytes:buf length:split - buf];
[self->unknownFieldData_ appendData:value];
[self->unknownFieldData_ appendBytes:split length:end - split];
}
GPB_NOINLINE
static void ParseUnknownField(GPBMessage *self, uint32_t tag, GPBCodedInputStream *input) {
if (self->unknownFields_) {
if (![self->unknownFields_ mergeFieldFrom:tag input:input]) {
GPBRaiseStreamError(GPBCodedInputStreamErrorInvalidTag, @"Unexpected end-group tag");
}
return;
}
uint8_t buf[20];
uint8_t *ptr = buf;
ptr = EncodeVarintU32(tag, ptr); // All will need the tag
NSData *bytesToAppend = nil;
GPBCodedInputStreamState *state = &input->state_;
switch (GPBWireFormatGetTagWireType(tag)) {
case GPBWireFormatVarint: {
ptr = EncodeVarintU64(GPBCodedInputStreamReadUInt64(state), ptr);
break;
}
case GPBWireFormatFixed64: {
uint64_t value = GPBCodedInputStreamReadFixed64(state);
*(ptr++) = (uint8_t)(value) & 0xFF;
*(ptr++) = (uint8_t)(value >> 8) & 0xFF;
*(ptr++) = (uint8_t)(value >> 16) & 0xFF;
*(ptr++) = (uint8_t)(value >> 24) & 0xFF;
*(ptr++) = (uint8_t)(value >> 32) & 0xFF;
*(ptr++) = (uint8_t)(value >> 40) & 0xFF;
*(ptr++) = (uint8_t)(value >> 48) & 0xFF;
*(ptr++) = (uint8_t)(value >> 56) & 0xFF;
break;
}
case GPBWireFormatLengthDelimited: {
bytesToAppend = GPBCodedInputStreamReadRetainedBytes(state);
ptr = EncodeVarintU64((uint64_t)bytesToAppend.length, ptr);
break;
}
case GPBWireFormatStartGroup: {
bytesToAppend = GPBCodedInputStreamReadRetainedBytesToEndGroupNoCopy(
state, GPBWireFormatGetTagFieldNumber(tag));
break;
}
case GPBWireFormatEndGroup:
GPBRaiseStreamError(GPBCodedInputStreamErrorInvalidTag, @"Unexpected end-group tag");
break;
case GPBWireFormatFixed32: {
uint32_t value = GPBCodedInputStreamReadFixed32(state);
*(ptr++) = (uint8_t)(value) & 0xFF;
*(ptr++) = (uint8_t)(value >> 8) & 0xFF;
*(ptr++) = (uint8_t)(value >> 16) & 0xFF;
*(ptr++) = (uint8_t)(value >> 24) & 0xFF;
break;
}
}
if (self->unknownFieldData_ == nil) {
self->unknownFieldData_ =
[[NSMutableData alloc] initWithCapacity:(ptr - buf) + bytesToAppend.length];
GPBBecomeVisibleToAutocreator(self);
}
[self->unknownFieldData_ appendBytes:buf length:ptr - buf];
if (bytesToAppend) {
[self->unknownFieldData_ appendData:bytesToAppend];
[bytesToAppend release];
}
}
static void CheckExtension(GPBMessage *self, GPBExtensionDescriptor *extension) {
if (![self isKindOfClass:extension.containingMessageClass]) {
[NSException raise:NSInvalidArgumentException
@ -916,7 +729,8 @@ static void DecodeSingleValueFromInputStream(GPBExtensionDescriptor *extension,
if (!enumDescriptor.isClosed || enumDescriptor.enumVerifier(val)) {
nsValue = [[NSNumber alloc] initWithInt:val];
} else {
AddUnknownFieldVarint32(messageToGetExtension, extension->description_->fieldNumber, val);
GPBUnknownFieldSet *unknownFields = GetOrMakeUnknownFields(messageToGetExtension);
[unknownFields mergeVarintField:extension->description_->fieldNumber value:val];
nsValue = nil;
}
break;
@ -1106,50 +920,12 @@ void GPBClearMessageAutocreator(GPBMessage *self) {
self->autocreatorExtension_ = nil;
}
GPB_NOINLINE
static void MergeUnknownFieldDataIntoFieldSet(GPBMessage *self, NSData *data,
GPBUnknownFieldSet *targetSet) {
GPBUnknownFieldSet *unknownFields = targetSet ? targetSet : self->unknownFields_;
#if defined(DEBUG) && DEBUG
NSCAssert(unknownFields != nil, @"Internal error: unknown fields not initialized.");
#endif
BOOL isMessageSet = self.descriptor.isWireFormat;
GPBUnknownFieldSet *decodeInto = isMessageSet ? [[GPBUnknownFieldSet alloc] init] : unknownFields;
GPBCodedInputStream *input = [[GPBCodedInputStream alloc] initWithData:data];
@try {
[decodeInto mergeFromCodedInputStream:input];
} @catch (NSException *exception) {
#if defined(DEBUG) && DEBUG
NSLog(@"%@: Internal exception while parsing the unknown fields into a Set: %@", [self class],
exception);
#endif
}
[input release];
if (isMessageSet) {
// Need to transform the groups back into how Message feeds the data into a MessageSet when
// doing a full MessageSet based decode.
GPBUnknownField *groupField = [decodeInto getField:GPBWireFormatMessageSetItem];
for (GPBUnknownFieldSet *group in groupField.groupList) {
GPBUnknownField *typeIdField = [group getField:GPBWireFormatMessageSetTypeId];
GPBUnknownField *messageField = [group getField:GPBWireFormatMessageSetMessage];
if (typeIdField.varintList.count != 1 || messageField.lengthDelimitedList.count != 1) {
#if defined(DEBUG) && DEBUG
NSCAssert(NO, @"Internal error: MessageSet group missing typeId or message.");
#endif
continue;
}
int32_t fieldNumber = (int32_t)[typeIdField.varintList valueAtIndex:0];
GPBUnknownField *messageSetField = [[GPBUnknownField alloc] initWithNumber:fieldNumber];
[messageSetField addLengthDelimited:messageField.lengthDelimitedList[0]];
[unknownFields addField:messageSetField];
[messageSetField release];
}
[decodeInto release];
static GPBUnknownFieldSet *GetOrMakeUnknownFields(GPBMessage *self) {
if (!self->unknownFields_) {
self->unknownFields_ = [[GPBUnknownFieldSet alloc] init];
GPBBecomeVisibleToAutocreator(self);
}
return self->unknownFields_;
}
@implementation GPBMessage
@ -1386,12 +1162,8 @@ static void MergeUnknownFieldDataIntoFieldSet(GPBMessage *self, NSData *data,
GPBMessage *result = [[descriptor.messageClass allocWithZone:zone] init];
[self copyFieldsInto:result zone:zone descriptor:descriptor];
@synchronized(self) {
result->unknownFields_ = [unknownFields_ copyWithZone:zone];
result->unknownFieldData_ = [unknownFieldData_ mutableCopyWithZone:zone];
}
// Make immutable copies of the extra bits.
result->unknownFields_ = [unknownFields_ copyWithZone:zone];
result->extensionMap_ = CloneExtensionMap(extensionMap_, zone);
return result;
}
@ -1465,8 +1237,6 @@ static void MergeUnknownFieldDataIntoFieldSet(GPBMessage *self, NSData *data,
[extensionMap_ release];
extensionMap_ = nil;
[unknownFieldData_ release];
unknownFieldData_ = nil;
[unknownFields_ release];
unknownFields_ = nil;
@ -1670,20 +1440,11 @@ static void MergeUnknownFieldDataIntoFieldSet(GPBMessage *self, NSData *data,
sortedExtensions:sortedExtensions];
}
}
@synchronized(self) {
if (unknownFieldData_) {
#if defined(DEBUG) && DEBUG
NSAssert(unknownFields_ == nil, @"Internal error both unknown states were set");
#endif
[output writeRawData:unknownFieldData_];
} else {
if (descriptor.isWireFormat) {
[unknownFields_ writeAsMessageSetTo:output];
} else {
[unknownFields_ writeToCodedOutputStream:output];
}
}
} // @synchronized(self)
if (descriptor.isWireFormat) {
[unknownFields_ writeAsMessageSetTo:output];
} else {
[unknownFields_ writeToCodedOutputStream:output];
}
}
- (void)writeDelimitedToOutputStream:(NSOutputStream *)output {
@ -2404,25 +2165,11 @@ static void MergeUnknownFieldDataIntoFieldSet(GPBMessage *self, NSData *data,
#pragma mark - Unknown Field Support
- (GPBUnknownFieldSet *)unknownFields {
@synchronized(self) {
if (unknownFieldData_) {
#if defined(DEBUG) && DEBUG
NSAssert(unknownFields_ == nil, @"Internal error both unknown states were set");
#endif
unknownFields_ = [[GPBUnknownFieldSet alloc] init];
MergeUnknownFieldDataIntoFieldSet(self, unknownFieldData_, nil);
[unknownFieldData_ release];
unknownFieldData_ = nil;
}
return unknownFields_;
} // @synchronized(self)
return unknownFields_;
}
- (void)setUnknownFields:(GPBUnknownFieldSet *)unknownFields {
if (unknownFields != unknownFields_ || unknownFieldData_ != nil) {
// Changing sets or clearing.
[unknownFieldData_ release];
unknownFieldData_ = nil;
if (unknownFields != unknownFields_) {
[unknownFields_ release];
unknownFields_ = [unknownFields copy];
GPBBecomeVisibleToAutocreator(self);
@ -2505,18 +2252,19 @@ static void MergeUnknownFieldDataIntoFieldSet(GPBMessage *self, NSData *data,
} else {
// The extension isn't in the registry, but it was well formed, so the whole group structure
// get preserved as an unknown field.
GPBUnknownFieldSet *unknownFields = GetOrMakeUnknownFields(self);
// rawBytes was created via a NoCopy, so it can be reusing a
// subrange of another NSData that might go out of scope as things
// unwind, so a copy is needed to ensure what is saved in the
// unknown fields stays valid.
NSData *cloned = [NSData dataWithData:rawBytes];
AddUnknownMessageSetEntry(self, typeId, cloned);
[unknownFields mergeMessageSetMessage:typeId data:cloned];
}
}
- (void)addUnknownMapEntry:(int32_t)fieldNum value:(NSData *)data {
AddUnknownFieldLengthDelimited(self, fieldNum, data);
GPBUnknownFieldSet *unknownFields = GetOrMakeUnknownFields(self);
[unknownFields addUnknownMapEntry:fieldNum value:data];
}
#pragma mark - MergeFromCodedInputStream Support
@ -2589,7 +2337,8 @@ static void MergeSingleFieldFromCodedInputStream(GPBMessage *self, GPBFieldDescr
if (!GPBFieldIsClosedEnum(field) || [field isValidEnumValue:val]) {
GPBSetInt32IvarWithFieldPrivate(self, field, val);
} else {
AddUnknownFieldVarint32(self, GPBFieldNumber(field), val);
GPBUnknownFieldSet *unknownFields = GetOrMakeUnknownFields(self);
[unknownFields mergeVarintField:GPBFieldNumber(field) value:val];
}
}
} // switch
@ -2638,7 +2387,8 @@ static void MergeRepeatedPackedFieldFromCodedInputStream(GPBMessage *self,
if (!GPBFieldIsClosedEnum(field) || [field isValidEnumValue:val]) {
[(GPBEnumArray *)genericArray addRawValue:val];
} else {
AddUnknownFieldVarint32(self, GPBFieldNumber(field), val);
GPBUnknownFieldSet *unknownFields = GetOrMakeUnknownFields(self);
[unknownFields mergeVarintField:GPBFieldNumber(field) value:val];
}
break;
}
@ -2706,7 +2456,8 @@ static void MergeRepeatedNotPackedFieldFromCodedInputStream(
if (!GPBFieldIsClosedEnum(field) || [field isValidEnumValue:val]) {
[(GPBEnumArray *)genericArray addRawValue:val];
} else {
AddUnknownFieldVarint32(self, GPBFieldNumber(field), val);
GPBUnknownFieldSet *unknownFields = GetOrMakeUnknownFields(self);
[unknownFields mergeVarintField:GPBFieldNumber(field) value:val];
}
break;
}
@ -2831,7 +2582,11 @@ static void MergeRepeatedNotPackedFieldFromCodedInputStream(
}
}
ParseUnknownField(self, tag, input);
GPBUnknownFieldSet *unknownFields = GetOrMakeUnknownFields(self);
if (![unknownFields mergeFieldFrom:tag input:input]) {
[NSException raise:NSInternalInconsistencyException
format:@"Internal Error: Unable to parse unknown field %u", tag];
}
} // while(YES)
}
@ -2953,29 +2708,10 @@ static void MergeRepeatedNotPackedFieldFromCodedInputStream(
} // for(fields)
// Unknown fields.
if (unknownFields_) {
#if defined(DEBUG) && DEBUG
NSAssert(unknownFieldData_ == nil, @"Internal error both unknown states were set");
#endif
@synchronized(other) {
if (other->unknownFields_) {
#if defined(DEBUG) && DEBUG
NSAssert(other->unknownFieldData_ == nil, @"Internal error both unknown states were set");
#endif
[unknownFields_ mergeUnknownFields:other->unknownFields_];
} else if (other->unknownFieldData_) {
MergeUnknownFieldDataIntoFieldSet(self, other->unknownFieldData_, nil);
}
} // @synchronized(other)
if (!unknownFields_) {
[self setUnknownFields:other.unknownFields];
} else {
NSData *otherData = GPBMessageUnknownFieldsData(other);
if (otherData) {
if (unknownFieldData_) {
[unknownFieldData_ appendData:otherData];
} else {
unknownFieldData_ = [otherData mutableCopy];
}
}
[unknownFields_ mergeUnknownFields:other.unknownFields];
}
// Extensions
@ -3147,72 +2883,15 @@ static void MergeRepeatedNotPackedFieldFromCodedInputStream(
}
}
// Mutation while another thread is doing read only access is invalid, so the only thing we
// need to guard against is concurrent r/o access, so we can grab the values (and retain them)
// so we have a version to compare against safely incase the second access causes the transform
// between internal states.
GPBUnknownFieldSet *selfUnknownFields;
NSData *selfUnknownFieldData;
@synchronized(self) {
selfUnknownFields = [unknownFields_ retain];
selfUnknownFieldData = [unknownFieldData_ retain];
}
GPBUnknownFieldSet *otherUnknownFields;
NSData *otherUnknownFieldData;
@synchronized(otherMsg) {
otherUnknownFields = [otherMsg->unknownFields_ retain];
otherUnknownFieldData = [otherMsg->unknownFieldData_ retain];
}
#if defined(DEBUG) && DEBUG && !defined(NS_BLOCK_ASSERTIONS)
if (selfUnknownFields) {
NSAssert(selfUnknownFieldData == nil, @"Internal error both unknown states were set");
}
if (otherUnknownFields) {
NSAssert(otherUnknownFieldData == nil, @"Internal error both unknown states were set");
}
#endif
// Since a developer can set the legacy unknownFieldSet, treat nil and empty as the same.
if (selfUnknownFields && selfUnknownFields.countOfFields == 0) {
[selfUnknownFields release];
selfUnknownFields = nil;
}
if (otherUnknownFields && otherUnknownFields.countOfFields == 0) {
[otherUnknownFields release];
otherUnknownFields = nil;
}
BOOL result = YES;
if (selfUnknownFieldData && otherUnknownFieldData) {
// Both had data, compare it.
result = [selfUnknownFieldData isEqual:otherUnknownFieldData];
} else if (selfUnknownFields && otherUnknownFields) {
// Both had fields set, compare them.
result = [selfUnknownFields isEqual:otherUnknownFields];
} else {
// At this point, we're done to one have a set/nothing, and the other having data/nothing.
GPBUnknownFieldSet *theSet = selfUnknownFields ? selfUnknownFields : otherUnknownFields;
NSData *theData = selfUnknownFieldData ? selfUnknownFieldData : otherUnknownFieldData;
if (theSet) {
if (theData) {
GPBUnknownFieldSet *tempSet = [[GPBUnknownFieldSet alloc] init];
MergeUnknownFieldDataIntoFieldSet(self, theData, tempSet);
result = [tempSet isEqual:theSet];
[tempSet release];
} else {
result = NO;
}
} else {
// It was a data/nothing and nothing, so they equal if the other didn't have data.
result = theData == nil;
// nil and empty are equal
GPBUnknownFieldSet *otherUnknowns = otherMsg->unknownFields_;
if ([unknownFields_ countOfFields] != 0 || [otherUnknowns countOfFields] != 0) {
if (![unknownFields_ isEqual:otherUnknowns]) {
return NO;
}
}
[selfUnknownFields release];
[selfUnknownFieldData release];
[otherUnknownFields release];
[otherUnknownFieldData release];
return result;
return YES;
}
// It is very difficult to implement a generic hash for ProtoBuf messages that
@ -3475,20 +3154,11 @@ static void MergeRepeatedNotPackedFieldFromCodedInputStream(
} // for(fields)
// Add any unknown fields.
@synchronized(self) {
if (unknownFieldData_) {
#if defined(DEBUG) && DEBUG
NSAssert(unknownFields_ == nil, @"Internal error both unknown states were set");
#endif
result += [unknownFieldData_ length];
} else {
if (descriptor.wireFormat) {
result += [unknownFields_ serializedSizeAsMessageSet];
} else {
result += [unknownFields_ serializedSize];
}
}
} // @synchronized(self)
if (descriptor.wireFormat) {
result += [unknownFields_ serializedSizeAsMessageSet];
} else {
result += [unknownFields_ serializedSize];
}
// Add any extensions.
for (GPBExtensionDescriptor *extension in extensionMap_) {
@ -4016,29 +3686,20 @@ id GPBGetObjectIvarWithField(GPBMessage *self, GPBFieldDescriptor *field) {
NSData *GPBMessageUnknownFieldsData(GPBMessage *self) {
NSData *result = nil;
@synchronized(self) {
GPBUnknownFieldSet *unknownFields = self->unknownFields_;
if (unknownFields) {
#if defined(DEBUG) && DEBUG
NSCAssert(self->unknownFieldData_ == nil, @"Internal error both unknown states were set");
#endif
if (self.descriptor.isWireFormat) {
NSMutableData *mutableData =
[NSMutableData dataWithLength:unknownFields.serializedSizeAsMessageSet];
GPBCodedOutputStream *output = [[GPBCodedOutputStream alloc] initWithData:mutableData];
[unknownFields writeAsMessageSetTo:output];
[output flush];
[output release];
result = mutableData;
} else {
result = [unknownFields data];
}
GPBUnknownFieldSet *unknownFields = self->unknownFields_;
if (unknownFields) {
if (self.descriptor.isWireFormat) {
NSMutableData *mutableData =
[NSMutableData dataWithLength:unknownFields.serializedSizeAsMessageSet];
GPBCodedOutputStream *output = [[GPBCodedOutputStream alloc] initWithData:mutableData];
[unknownFields writeAsMessageSetTo:output];
[output flush];
[output release];
result = mutableData;
} else {
// Internally we can borrow it without a copy since this is immediately used by callers
// and multithreaded access with any mutation is not allow on messages.
result = self->unknownFieldData_;
result = [unknownFields data];
}
} // @synchronized(self)
}
return result;
}

@ -271,11 +271,6 @@ static void GPBUnknownFieldSetMergeUnknownFields(__unused const void *key, const
[[self mutableFieldForNumber:number create:YES] addVarint:value];
}
- (void)mergeLengthDelimited:(int32_t)fieldNum value:(NSData *)value {
checkNumber(fieldNum);
[[self mutableFieldForNumber:fieldNum create:YES] addLengthDelimited:value];
}
- (BOOL)mergeFieldFrom:(int32_t)tag input:(GPBCodedInputStream *)input {
NSAssert(GPBWireFormatIsValidTag(tag), @"Got passed an invalid tag");
int32_t number = GPBWireFormatGetTagFieldNumber(tag);
@ -318,6 +313,15 @@ static void GPBUnknownFieldSetMergeUnknownFields(__unused const void *key, const
}
}
- (void)mergeMessageSetMessage:(int32_t)number data:(NSData *)messageData {
[[self mutableFieldForNumber:number create:YES] addLengthDelimited:messageData];
}
- (void)addUnknownMapEntry:(int32_t)fieldNum value:(NSData *)data {
GPBUnknownField *field = [self mutableFieldForNumber:fieldNum create:YES];
[field addLengthDelimited:data];
}
- (void)mergeFromCodedInputStream:(GPBCodedInputStream *)input {
while (YES) {
int32_t tag = GPBCodedInputStreamReadTag(&input->state_);

@ -27,7 +27,9 @@
- (void)mergeFromCodedInputStream:(GPBCodedInputStream *)input;
- (void)mergeVarintField:(int32_t)number value:(int32_t)value;
- (void)mergeLengthDelimited:(int32_t)number value:(NSData *)value;
- (BOOL)mergeFieldFrom:(int32_t)tag input:(GPBCodedInputStream *)input;
- (void)mergeMessageSetMessage:(int32_t)number data:(NSData *)messageData;
- (void)addUnknownMapEntry:(int32_t)fieldNum value:(NSData *)data;
@end

Loading…
Cancel
Save