objectivec/GPBExtensionField.m - third_party/protobuf - Git at Google

 // 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 "GPBExtensionField_PackagePrivate.h"

 #import <objc/runtime.h>

 #import "GPBCodedInputStream_PackagePrivate.h"
 #import "GPBCodedOutputStream.h"
 #import "GPBDescriptor_PackagePrivate.h"
 #import "GPBMessage_PackagePrivate.h"
 #import "GPBUtilities_PackagePrivate.h"

 GPB_INLINE size_t TypeSize(GPBType type) {
   switch (type) {
     case GPBTypeBool:
       return 1;
     case GPBTypeFixed32:
     case GPBTypeSFixed32:
     case GPBTypeFloat:
       return 4;
     case GPBTypeFixed64:
     case GPBTypeSFixed64:
     case GPBTypeDouble:
       return 8;
     default:
       return 0;
   }
 }

 GPB_INLINE BOOL ExtensionIsRepeated(GPBExtensionDescription *description) {
   return (description->options & GPBExtensionRepeated) != 0;
 }

 GPB_INLINE BOOL ExtensionIsPacked(GPBExtensionDescription *description) {
   return (description->options & GPBExtensionPacked) != 0;
 }

 GPB_INLINE BOOL ExtensionIsWireFormat(GPBExtensionDescription *description) {
   return (description->options & GPBExtensionSetWireFormat) != 0;
 }

 static size_t ComputePBSerializedSizeNoTagOfObject(GPBType type, id object) {
 #define FIELD_CASE(TYPE, ACCESSOR) \
   case GPBType##TYPE:              \
     return GPBCompute##TYPE##SizeNoTag([(NSNumber *)object ACCESSOR]);
 #define FIELD_CASE2(TYPE) \
   case GPBType##TYPE:     \
     return GPBCompute##TYPE##SizeNoTag(object);
   switch (type) {
     FIELD_CASE(Bool, boolValue)
     FIELD_CASE(Float, floatValue)
     FIELD_CASE(Double, doubleValue)
     FIELD_CASE(Int32, intValue)
     FIELD_CASE(SFixed32, intValue)
     FIELD_CASE(SInt32, intValue)
     FIELD_CASE(Enum, intValue)
     FIELD_CASE(Int64, longLongValue)
     FIELD_CASE(SInt64, longLongValue)
     FIELD_CASE(SFixed64, longLongValue)
     FIELD_CASE(UInt32, unsignedIntValue)
     FIELD_CASE(Fixed32, unsignedIntValue)
     FIELD_CASE(UInt64, unsignedLongLongValue)
     FIELD_CASE(Fixed64, unsignedLongLongValue)
     FIELD_CASE2(Data)
     FIELD_CASE2(String)
     FIELD_CASE2(Message)
     FIELD_CASE2(Group)
   }
 #undef FIELD_CASE
 #undef FIELD_CASE2
 }

 static size_t ComputeSerializedSizeIncludingTagOfObject(
     GPBExtensionDescription *description, id object) {
 #define FIELD_CASE(TYPE, ACCESSOR)                          \
   case GPBType##TYPE:                                       \
     return GPBCompute##TYPE##Size(description->fieldNumber, \
                                   [(NSNumber *)object ACCESSOR]);
 #define FIELD_CASE2(TYPE) \
   case GPBType##TYPE:     \
     return GPBCompute##TYPE##Size(description->fieldNumber, object);
   switch (description->type) {
     FIELD_CASE(Bool, boolValue)
     FIELD_CASE(Float, floatValue)
     FIELD_CASE(Double, doubleValue)
     FIELD_CASE(Int32, intValue)
     FIELD_CASE(SFixed32, intValue)
     FIELD_CASE(SInt32, intValue)
     FIELD_CASE(Enum, intValue)
     FIELD_CASE(Int64, longLongValue)
     FIELD_CASE(SInt64, longLongValue)
     FIELD_CASE(SFixed64, longLongValue)
     FIELD_CASE(UInt32, unsignedIntValue)
     FIELD_CASE(Fixed32, unsignedIntValue)
     FIELD_CASE(UInt64, unsignedLongLongValue)
     FIELD_CASE(Fixed64, unsignedLongLongValue)
     FIELD_CASE2(Data)
     FIELD_CASE2(String)
     FIELD_CASE2(Group)
     case GPBTypeMessage:
       if (ExtensionIsWireFormat(description)) {
         return GPBComputeMessageSetExtensionSize(description->fieldNumber,
                                                  object);
       } else {
         return GPBComputeMessageSize(description->fieldNumber, object);
       }
   }
 #undef FIELD_CASE
 #undef FIELD_CASE2
 }

 static size_t ComputeSerializedSizeIncludingTagOfArray(
     GPBExtensionDescription *description, NSArray *values) {
   if (ExtensionIsPacked(description)) {
     size_t size = 0;
     size_t typeSize = TypeSize(description->type);
     if (typeSize != 0) {
       size = values.count * typeSize;
     } else {
       for (id value in values) {
         size += ComputePBSerializedSizeNoTagOfObject(description->type, value);
       }
     }
     return size + GPBComputeTagSize(description->fieldNumber) +
            GPBComputeRawVarint32SizeForInteger(size);
   } else {
     size_t size = 0;
     for (id value in values) {
       size += ComputeSerializedSizeIncludingTagOfObject(description, value);
     }
     return size;
   }
 }

 static void WriteObjectIncludingTagToCodedOutputStream(
     id object, GPBExtensionDescription *description,
     GPBCodedOutputStream *output) {
 #define FIELD_CASE(TYPE, ACCESSOR)                      \
   case GPBType##TYPE:                                   \
     [output write##TYPE:description->fieldNumber        \
                   value:[(NSNumber *)object ACCESSOR]]; \
     return;
 #define FIELD_CASE2(TYPE)                                       \
   case GPBType##TYPE:                                           \
     [output write##TYPE:description->fieldNumber value:object]; \
     return;
   switch (description->type) {
     FIELD_CASE(Bool, boolValue)
     FIELD_CASE(Float, floatValue)
     FIELD_CASE(Double, doubleValue)
     FIELD_CASE(Int32, intValue)
     FIELD_CASE(SFixed32, intValue)
     FIELD_CASE(SInt32, intValue)
     FIELD_CASE(Enum, intValue)
     FIELD_CASE(Int64, longLongValue)
     FIELD_CASE(SInt64, longLongValue)
     FIELD_CASE(SFixed64, longLongValue)
     FIELD_CASE(UInt32, unsignedIntValue)
     FIELD_CASE(Fixed32, unsignedIntValue)
     FIELD_CASE(UInt64, unsignedLongLongValue)
     FIELD_CASE(Fixed64, unsignedLongLongValue)
     FIELD_CASE2(Data)
     FIELD_CASE2(String)
     FIELD_CASE2(Group)
     case GPBTypeMessage:
       if (ExtensionIsWireFormat(description)) {
         [output writeMessageSetExtension:description->fieldNumber value:object];
       } else {
         [output writeMessage:description->fieldNumber value:object];
       }
       return;
   }
 #undef FIELD_CASE
 #undef FIELD_CASE2
 }

 static void WriteObjectNoTagToCodedOutputStream(
     id object, GPBExtensionDescription *description,
     GPBCodedOutputStream *output) {
 #define FIELD_CASE(TYPE, ACCESSOR)                             \
   case GPBType##TYPE:                                          \
     [output write##TYPE##NoTag:[(NSNumber *)object ACCESSOR]]; \
     return;
 #define FIELD_CASE2(TYPE)               \
   case GPBType##TYPE:                   \
     [output write##TYPE##NoTag:object]; \
     return;
   switch (description->type) {
     FIELD_CASE(Bool, boolValue)
     FIELD_CASE(Float, floatValue)
     FIELD_CASE(Double, doubleValue)
     FIELD_CASE(Int32, intValue)
     FIELD_CASE(SFixed32, intValue)
     FIELD_CASE(SInt32, intValue)
     FIELD_CASE(Enum, intValue)
     FIELD_CASE(Int64, longLongValue)
     FIELD_CASE(SInt64, longLongValue)
     FIELD_CASE(SFixed64, longLongValue)
     FIELD_CASE(UInt32, unsignedIntValue)
     FIELD_CASE(Fixed32, unsignedIntValue)
     FIELD_CASE(UInt64, unsignedLongLongValue)
     FIELD_CASE(Fixed64, unsignedLongLongValue)
     FIELD_CASE2(Data)
     FIELD_CASE2(String)
     FIELD_CASE2(Message)
     case GPBTypeGroup:
       [output writeGroupNoTag:description->fieldNumber value:object];
       return;
   }
 #undef FIELD_CASE
 #undef FIELD_CASE2
 }

 static void WriteArrayIncludingTagsToCodedOutputStream(
     NSArray *values, GPBExtensionDescription *description,
     GPBCodedOutputStream *output) {
   if (ExtensionIsPacked(description)) {
     [output writeTag:description->fieldNumber
               format:GPBWireFormatLengthDelimited];
     size_t dataSize = 0;
     size_t typeSize = TypeSize(description->type);
     if (typeSize != 0) {
       dataSize = values.count * typeSize;
     } else {
       for (id value in values) {
         dataSize +=
             ComputePBSerializedSizeNoTagOfObject(description->type, value);
       }
     }
     [output writeRawVarintSizeTAs32:dataSize];
     for (id value in values) {
       WriteObjectNoTagToCodedOutputStream(value, description, output);
     }
   } else {
     for (id value in values) {
       WriteObjectIncludingTagToCodedOutputStream(value, description, output);
     }
   }
 }

 @implementation GPBExtensionField {
   GPBExtensionDescription *description_;
   GPBExtensionDescriptor *descriptor_;
   GPBValue defaultValue_;
 }

 @synthesize containingType = containingType_;
 @synthesize descriptor = descriptor_;

 - (instancetype)init {
   // Throw an exception if people attempt to not use the designated initializer.
   self = [super init];
   if (self != nil) {
     [self doesNotRecognizeSelector:_cmd];
     self = nil;
   }
   return self;
 }

 - (instancetype)initWithDescription:(GPBExtensionDescription *)description {
   if ((self = [super init])) {
     description_ = description;
     if (description->extendedClass) {
       Class containingClass = objc_lookUpClass(description->extendedClass);
       NSAssert1(containingClass, @"Class %s not defined",
                 description->extendedClass);
       containingType_ = [containingClass descriptor];
     }
 #if DEBUG
     const char *className = description->messageOrGroupClassName;
     if (className) {
       NSAssert1(objc_lookUpClass(className) != Nil, @"Class %s not defined",
                 className);
     }
 #endif
     descriptor_ = [[GPBExtensionDescriptor alloc]
         initWithExtensionDescription:description];
     GPBType type = description_->type;
     if (type == GPBTypeData) {
       // Data stored as a length prefixed c-string in descriptor records.
       const uint8_t *bytes =
           (const uint8_t *)description->defaultValue.valueData;
       if (bytes) {
         uint32_t length = *((uint32_t *)bytes);
         // The length is stored in network byte order.
         length = ntohl(length);
         bytes += sizeof(length);
         defaultValue_.valueData =
             [[NSData alloc] initWithBytes:bytes length:length];
       }
     } else if (type == GPBTypeMessage || type == GPBTypeGroup) {
       // The default is looked up in -defaultValue instead since extensions
       // aren't
       // common, we avoid the hit startup hit and it avoid initialization order
       // issues.
     } else {
       defaultValue_ = description->defaultValue;
     }
   }
   return self;
 }

 - (void)dealloc {
   if ((description_->type == GPBTypeData) &&
       !ExtensionIsRepeated(description_)) {
     [defaultValue_.valueData release];
   }
   [descriptor_ release];
   [super dealloc];
 }

 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> FieldNumber:%d ContainingType:%@",
                                     [self class], self, self.fieldNumber,
                                     self.containingType];
 }

 - (id)copyWithZone:(NSZone *)__unused zone {
   return [self retain];
 }

 #pragma mark Properties

 - (int32_t)fieldNumber {
   return description_->fieldNumber;
 }

 - (GPBWireFormat)wireType {
   return GPBWireFormatForType(description_->type,
                               ExtensionIsPacked(description_));
 }

 - (BOOL)isRepeated {
   return ExtensionIsRepeated(description_);
 }

 - (id)defaultValue {
   if (ExtensionIsRepeated(description_)) {
     return nil;
   }

   switch (description_->type) {
     case GPBTypeBool:
       return @(defaultValue_.valueBool);
     case GPBTypeFloat:
       return @(defaultValue_.valueFloat);
     case GPBTypeDouble:
       return @(defaultValue_.valueDouble);
     case GPBTypeInt32:
     case GPBTypeSInt32:
     case GPBTypeEnum:
     case GPBTypeSFixed32:
       return @(defaultValue_.valueInt32);
     case GPBTypeInt64:
     case GPBTypeSInt64:
     case GPBTypeSFixed64:
       return @(defaultValue_.valueInt64);
     case GPBTypeUInt32:
     case GPBTypeFixed32:
       return @(defaultValue_.valueUInt32);
     case GPBTypeUInt64:
     case GPBTypeFixed64:
       return @(defaultValue_.valueUInt64);
     case GPBTypeData:
       // Like message fields, the default is zero length data.
       return (defaultValue_.valueData ? defaultValue_.valueData
                                       : GPBEmptyNSData());
     case GPBTypeString:
       // Like message fields, the default is zero length string.
       return (defaultValue_.valueString ? defaultValue_.valueString : @"");
     case GPBTypeGroup:
     case GPBTypeMessage:
       NSAssert(0, @"Shouldn't get here");
       return nil;
   }
 }

 #pragma mark Internals

 - (void)mergeFromCodedInputStream:(GPBCodedInputStream *)input
                 extensionRegistry:(GPBExtensionRegistry *)extensionRegistry
                           message:(GPBMessage *)message {
   GPBCodedInputStreamState *state = &input->state_;
   if (ExtensionIsPacked(description_)) {
     int32_t length = GPBCodedInputStreamReadInt32(state);
     size_t limit = GPBCodedInputStreamPushLimit(state, length);
     while (GPBCodedInputStreamBytesUntilLimit(state) > 0) {
       id value = [self newSingleValueFromCodedInputStream:input
                                         extensionRegistry:extensionRegistry
                                             existingValue:nil];
       [message addExtension:self value:value];
       [value release];
     }
     GPBCodedInputStreamPopLimit(state, limit);
   } else {
     id existingValue = nil;
     BOOL isRepeated = ExtensionIsRepeated(description_);
     if (!isRepeated && GPBTypeIsMessage(description_->type)) {
       existingValue = [message getExistingExtension:self];
     }
     id value = [self newSingleValueFromCodedInputStream:input
                                       extensionRegistry:extensionRegistry
                                           existingValue:existingValue];
     if (isRepeated) {
       [message addExtension:self value:value];
     } else {
       [message setExtension:self value:value];
     }
     [value release];
   }
 }

 - (void)writeValue:(id)value
     includingTagToCodedOutputStream:(GPBCodedOutputStream *)output {
   if (ExtensionIsRepeated(description_)) {
     WriteArrayIncludingTagsToCodedOutputStream(value, description_, output);
   } else {
     WriteObjectIncludingTagToCodedOutputStream(value, description_, output);
   }
 }

 - (size_t)computeSerializedSizeIncludingTag:(id)value {
   if (ExtensionIsRepeated(description_)) {
     return ComputeSerializedSizeIncludingTagOfArray(description_, value);
   } else {
     return ComputeSerializedSizeIncludingTagOfObject(description_, value);
   }
 }

 // Note that this returns a retained value intentionally.
 - (id)newSingleValueFromCodedInputStream:(GPBCodedInputStream *)input
                         extensionRegistry:(GPBExtensionRegistry *)extensionRegistry
                             existingValue:(GPBMessage *)existingValue {
   GPBCodedInputStreamState *state = &input->state_;
   switch (description_->type) {
     case GPBTypeBool:     return [[NSNumber alloc] initWithBool:GPBCodedInputStreamReadBool(state)];
     case GPBTypeFixed32:  return [[NSNumber alloc] initWithUnsignedInt:GPBCodedInputStreamReadFixed32(state)];
     case GPBTypeSFixed32: return [[NSNumber alloc] initWithInt:GPBCodedInputStreamReadSFixed32(state)];
     case GPBTypeFloat:    return [[NSNumber alloc] initWithFloat:GPBCodedInputStreamReadFloat(state)];
     case GPBTypeFixed64:  return [[NSNumber alloc] initWithUnsignedLongLong:GPBCodedInputStreamReadFixed64(state)];
     case GPBTypeSFixed64: return [[NSNumber alloc] initWithLongLong:GPBCodedInputStreamReadSFixed64(state)];
     case GPBTypeDouble:   return [[NSNumber alloc] initWithDouble:GPBCodedInputStreamReadDouble(state)];
     case GPBTypeInt32:    return [[NSNumber alloc] initWithInt:GPBCodedInputStreamReadInt32(state)];
     case GPBTypeInt64:    return [[NSNumber alloc] initWithLongLong:GPBCodedInputStreamReadInt64(state)];
     case GPBTypeSInt32:   return [[NSNumber alloc] initWithInt:GPBCodedInputStreamReadSInt32(state)];
     case GPBTypeSInt64:   return [[NSNumber alloc] initWithLongLong:GPBCodedInputStreamReadSInt64(state)];
     case GPBTypeUInt32:   return [[NSNumber alloc] initWithUnsignedInt:GPBCodedInputStreamReadUInt32(state)];
     case GPBTypeUInt64:   return [[NSNumber alloc] initWithUnsignedLongLong:GPBCodedInputStreamReadUInt64(state)];
     case GPBTypeData:     return GPBCodedInputStreamReadRetainedData(state);
     case GPBTypeString:   return GPBCodedInputStreamReadRetainedString(state);
     case GPBTypeEnum:     return [[NSNumber alloc] initWithInt:GPBCodedInputStreamReadEnum(state)];
     case GPBTypeGroup:
     case GPBTypeMessage: {
       GPBMessage *message;
       if (existingValue) {
         message = [existingValue retain];
       } else {
         GPBDescriptor *decriptor = [descriptor_.msgClass descriptor];
         message = [[decriptor.messageClass alloc] init];
       }

       if (description_->type == GPBTypeGroup) {
         [input readGroup:description_->fieldNumber
                  message:message
             extensionRegistry:extensionRegistry];
       } else {
         // description_->type == GPBTypeMessage
         if (ExtensionIsWireFormat(description_)) {
           // For MessageSet fields the message length will have already been
           // read.
           [message mergeFromCodedInputStream:input
                            extensionRegistry:extensionRegistry];
         } else {
           [input readMessage:message extensionRegistry:extensionRegistry];
         }
       }

       return message;
     }
   }

   return nil;
 }

 - (NSComparisonResult)compareByFieldNumber:(GPBExtensionField *)other {
   int32_t selfNumber = description_->fieldNumber;
   int32_t otherNumber = other->description_->fieldNumber;
   if (selfNumber < otherNumber) {
     return NSOrderedAscending;
   } else if (selfNumber == otherNumber) {
     return NSOrderedSame;
   } else {
     return NSOrderedDescending;
   }
 }

 @end
	// 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 "GPBExtensionField_PackagePrivate.h"

	#import <objc/runtime.h>

	#import "GPBCodedInputStream_PackagePrivate.h"
	#import "GPBCodedOutputStream.h"
	#import "GPBDescriptor_PackagePrivate.h"
	#import "GPBMessage_PackagePrivate.h"
	#import "GPBUtilities_PackagePrivate.h"

	GPB_INLINE size_t TypeSize(GPBType type) {
	switch (type) {
	case GPBTypeBool:
	return 1;
	case GPBTypeFixed32:
	case GPBTypeSFixed32:
	case GPBTypeFloat:
	return 4;
	case GPBTypeFixed64:
	case GPBTypeSFixed64:
	case GPBTypeDouble:
	return 8;
	default:
	return 0;
	}
	}

	GPB_INLINE BOOL ExtensionIsRepeated(GPBExtensionDescription *description) {
	return (description->options & GPBExtensionRepeated) != 0;
	}

	GPB_INLINE BOOL ExtensionIsPacked(GPBExtensionDescription *description) {
	return (description->options & GPBExtensionPacked) != 0;
	}

	GPB_INLINE BOOL ExtensionIsWireFormat(GPBExtensionDescription *description) {
	return (description->options & GPBExtensionSetWireFormat) != 0;
	}

	static size_t ComputePBSerializedSizeNoTagOfObject(GPBType type, id object) {
	#define FIELD_CASE(TYPE, ACCESSOR) \
	case GPBType##TYPE: \
	return GPBCompute##TYPE##SizeNoTag([(NSNumber *)object ACCESSOR]);
	#define FIELD_CASE2(TYPE) \
	case GPBType##TYPE: \
	return GPBCompute##TYPE##SizeNoTag(object);
	switch (type) {
	FIELD_CASE(Bool, boolValue)
	FIELD_CASE(Float, floatValue)
	FIELD_CASE(Double, doubleValue)
	FIELD_CASE(Int32, intValue)
	FIELD_CASE(SFixed32, intValue)
	FIELD_CASE(SInt32, intValue)
	FIELD_CASE(Enum, intValue)
	FIELD_CASE(Int64, longLongValue)
	FIELD_CASE(SInt64, longLongValue)
	FIELD_CASE(SFixed64, longLongValue)
	FIELD_CASE(UInt32, unsignedIntValue)
	FIELD_CASE(Fixed32, unsignedIntValue)
	FIELD_CASE(UInt64, unsignedLongLongValue)
	FIELD_CASE(Fixed64, unsignedLongLongValue)
	FIELD_CASE2(Data)
	FIELD_CASE2(String)
	FIELD_CASE2(Message)
	FIELD_CASE2(Group)
	}
	#undef FIELD_CASE
	#undef FIELD_CASE2
	}

	static size_t ComputeSerializedSizeIncludingTagOfObject(
	GPBExtensionDescription *description, id object) {
	#define FIELD_CASE(TYPE, ACCESSOR) \
	case GPBType##TYPE: \
	return GPBCompute##TYPE##Size(description->fieldNumber, \
	[(NSNumber *)object ACCESSOR]);
	#define FIELD_CASE2(TYPE) \
	case GPBType##TYPE: \
	return GPBCompute##TYPE##Size(description->fieldNumber, object);
	switch (description->type) {
	FIELD_CASE(Bool, boolValue)
	FIELD_CASE(Float, floatValue)
	FIELD_CASE(Double, doubleValue)
	FIELD_CASE(Int32, intValue)
	FIELD_CASE(SFixed32, intValue)
	FIELD_CASE(SInt32, intValue)
	FIELD_CASE(Enum, intValue)
	FIELD_CASE(Int64, longLongValue)
	FIELD_CASE(SInt64, longLongValue)
	FIELD_CASE(SFixed64, longLongValue)
	FIELD_CASE(UInt32, unsignedIntValue)
	FIELD_CASE(Fixed32, unsignedIntValue)
	FIELD_CASE(UInt64, unsignedLongLongValue)
	FIELD_CASE(Fixed64, unsignedLongLongValue)
	FIELD_CASE2(Data)
	FIELD_CASE2(String)
	FIELD_CASE2(Group)
	case GPBTypeMessage:
	if (ExtensionIsWireFormat(description)) {
	return GPBComputeMessageSetExtensionSize(description->fieldNumber,
	object);
	} else {
	return GPBComputeMessageSize(description->fieldNumber, object);
	}
	}
	#undef FIELD_CASE
	#undef FIELD_CASE2
	}

	static size_t ComputeSerializedSizeIncludingTagOfArray(
	GPBExtensionDescription description, NSArray values) {
	if (ExtensionIsPacked(description)) {
	size_t size = 0;
	size_t typeSize = TypeSize(description->type);
	if (typeSize != 0) {
	size = values.count * typeSize;
	} else {
	for (id value in values) {
	size += ComputePBSerializedSizeNoTagOfObject(description->type, value);
	}
	}
	return size + GPBComputeTagSize(description->fieldNumber) +
	GPBComputeRawVarint32SizeForInteger(size);
	} else {
	size_t size = 0;
	for (id value in values) {
	size += ComputeSerializedSizeIncludingTagOfObject(description, value);
	}
	return size;
	}
	}

	static void WriteObjectIncludingTagToCodedOutputStream(
	id object, GPBExtensionDescription *description,
	GPBCodedOutputStream *output) {
	#define FIELD_CASE(TYPE, ACCESSOR) \
	case GPBType##TYPE: \
	[output write##TYPE:description->fieldNumber \
	value:[(NSNumber *)object ACCESSOR]]; \
	return;
	#define FIELD_CASE2(TYPE) \
	case GPBType##TYPE: \
	[output write##TYPE:description->fieldNumber value:object]; \
	return;
	switch (description->type) {
	FIELD_CASE(Bool, boolValue)
	FIELD_CASE(Float, floatValue)
	FIELD_CASE(Double, doubleValue)
	FIELD_CASE(Int32, intValue)
	FIELD_CASE(SFixed32, intValue)
	FIELD_CASE(SInt32, intValue)
	FIELD_CASE(Enum, intValue)
	FIELD_CASE(Int64, longLongValue)
	FIELD_CASE(SInt64, longLongValue)
	FIELD_CASE(SFixed64, longLongValue)
	FIELD_CASE(UInt32, unsignedIntValue)
	FIELD_CASE(Fixed32, unsignedIntValue)
	FIELD_CASE(UInt64, unsignedLongLongValue)
	FIELD_CASE(Fixed64, unsignedLongLongValue)
	FIELD_CASE2(Data)
	FIELD_CASE2(String)
	FIELD_CASE2(Group)
	case GPBTypeMessage:
	if (ExtensionIsWireFormat(description)) {
	[output writeMessageSetExtension:description->fieldNumber value:object];
	} else {
	[output writeMessage:description->fieldNumber value:object];
	}
	return;
	}
	#undef FIELD_CASE
	#undef FIELD_CASE2
	}

	static void WriteObjectNoTagToCodedOutputStream(
	id object, GPBExtensionDescription *description,
	GPBCodedOutputStream *output) {
	#define FIELD_CASE(TYPE, ACCESSOR) \
	case GPBType##TYPE: \
	[output write##TYPE##NoTag:[(NSNumber *)object ACCESSOR]]; \
	return;
	#define FIELD_CASE2(TYPE) \
	case GPBType##TYPE: \
	[output write##TYPE##NoTag:object]; \
	return;
	switch (description->type) {
	FIELD_CASE(Bool, boolValue)
	FIELD_CASE(Float, floatValue)
	FIELD_CASE(Double, doubleValue)
	FIELD_CASE(Int32, intValue)
	FIELD_CASE(SFixed32, intValue)
	FIELD_CASE(SInt32, intValue)
	FIELD_CASE(Enum, intValue)
	FIELD_CASE(Int64, longLongValue)
	FIELD_CASE(SInt64, longLongValue)
	FIELD_CASE(SFixed64, longLongValue)
	FIELD_CASE(UInt32, unsignedIntValue)
	FIELD_CASE(Fixed32, unsignedIntValue)
	FIELD_CASE(UInt64, unsignedLongLongValue)
	FIELD_CASE(Fixed64, unsignedLongLongValue)
	FIELD_CASE2(Data)
	FIELD_CASE2(String)
	FIELD_CASE2(Message)
	case GPBTypeGroup:
	[output writeGroupNoTag:description->fieldNumber value:object];
	return;
	}
	#undef FIELD_CASE
	#undef FIELD_CASE2
	}

	static void WriteArrayIncludingTagsToCodedOutputStream(
	NSArray values, GPBExtensionDescription description,
	GPBCodedOutputStream *output) {
	if (ExtensionIsPacked(description)) {
	[output writeTag:description->fieldNumber
	format:GPBWireFormatLengthDelimited];
	size_t dataSize = 0;
	size_t typeSize = TypeSize(description->type);
	if (typeSize != 0) {
	dataSize = values.count * typeSize;
	} else {
	for (id value in values) {
	dataSize +=
	ComputePBSerializedSizeNoTagOfObject(description->type, value);
	}
	}
	[output writeRawVarintSizeTAs32:dataSize];
	for (id value in values) {
	WriteObjectNoTagToCodedOutputStream(value, description, output);
	}
	} else {
	for (id value in values) {
	WriteObjectIncludingTagToCodedOutputStream(value, description, output);
	}
	}
	}

	@implementation GPBExtensionField {
	GPBExtensionDescription *description_;
	GPBExtensionDescriptor *descriptor_;
	GPBValue defaultValue_;
	}

	@synthesize containingType = containingType_;
	@synthesize descriptor = descriptor_;

	- (instancetype)init {
	// Throw an exception if people attempt to not use the designated initializer.
	self = [super init];
	if (self != nil) {
	[self doesNotRecognizeSelector:_cmd];
	self = nil;
	}
	return self;
	}

	- (instancetype)initWithDescription:(GPBExtensionDescription *)description {
	if ((self = [super init])) {
	description_ = description;
	if (description->extendedClass) {
	Class containingClass = objc_lookUpClass(description->extendedClass);
	NSAssert1(containingClass, @"Class %s not defined",
	description->extendedClass);
	containingType_ = [containingClass descriptor];
	}
	#if DEBUG
	const char *className = description->messageOrGroupClassName;
	if (className) {
	NSAssert1(objc_lookUpClass(className) != Nil, @"Class %s not defined",
	className);
	}
	#endif
	descriptor_ = [[GPBExtensionDescriptor alloc]
	initWithExtensionDescription:description];
	GPBType type = description_->type;
	if (type == GPBTypeData) {
	// Data stored as a length prefixed c-string in descriptor records.
	const uint8_t *bytes =
	(const uint8_t *)description->defaultValue.valueData;
	if (bytes) {
	uint32_t length = ((uint32_t )bytes);
	// The length is stored in network byte order.
	length = ntohl(length);
	bytes += sizeof(length);
	defaultValue_.valueData =
	[[NSData alloc] initWithBytes:bytes length:length];
	}
	} else if (type == GPBTypeMessage \|\| type == GPBTypeGroup) {
	// The default is looked up in -defaultValue instead since extensions
	// aren't
	// common, we avoid the hit startup hit and it avoid initialization order
	// issues.
	} else {
	defaultValue_ = description->defaultValue;
	}
	}
	return self;
	}

	- (void)dealloc {
	if ((description_->type == GPBTypeData) &&
	!ExtensionIsRepeated(description_)) {
	[defaultValue_.valueData release];
	}
	[descriptor_ release];
	[super dealloc];
	}

	- (NSString *)description {
	return [NSString stringWithFormat:@"<%@ %p> FieldNumber:%d ContainingType:%@",
	[self class], self, self.fieldNumber,
	self.containingType];
	}

	- (id)copyWithZone:(NSZone *)__unused zone {
	return [self retain];
	}

	#pragma mark Properties

	- (int32_t)fieldNumber {
	return description_->fieldNumber;
	}

	- (GPBWireFormat)wireType {
	return GPBWireFormatForType(description_->type,
	ExtensionIsPacked(description_));
	}

	- (BOOL)isRepeated {
	return ExtensionIsRepeated(description_);
	}

	- (id)defaultValue {
	if (ExtensionIsRepeated(description_)) {
	return nil;
	}

	switch (description_->type) {
	case GPBTypeBool:
	return @(defaultValue_.valueBool);
	case GPBTypeFloat:
	return @(defaultValue_.valueFloat);
	case GPBTypeDouble:
	return @(defaultValue_.valueDouble);
	case GPBTypeInt32:
	case GPBTypeSInt32:
	case GPBTypeEnum:
	case GPBTypeSFixed32:
	return @(defaultValue_.valueInt32);
	case GPBTypeInt64:
	case GPBTypeSInt64:
	case GPBTypeSFixed64:
	return @(defaultValue_.valueInt64);
	case GPBTypeUInt32:
	case GPBTypeFixed32:
	return @(defaultValue_.valueUInt32);
	case GPBTypeUInt64:
	case GPBTypeFixed64:
	return @(defaultValue_.valueUInt64);
	case GPBTypeData:
	// Like message fields, the default is zero length data.
	return (defaultValue_.valueData ? defaultValue_.valueData
	: GPBEmptyNSData());
	case GPBTypeString:
	// Like message fields, the default is zero length string.
	return (defaultValue_.valueString ? defaultValue_.valueString : @"");
	case GPBTypeGroup:
	case GPBTypeMessage:
	NSAssert(0, @"Shouldn't get here");
	return nil;
	}
	}

	#pragma mark Internals

	- (void)mergeFromCodedInputStream:(GPBCodedInputStream *)input
	extensionRegistry:(GPBExtensionRegistry *)extensionRegistry
	message:(GPBMessage *)message {
	GPBCodedInputStreamState *state = &input->state_;
	if (ExtensionIsPacked(description_)) {
	int32_t length = GPBCodedInputStreamReadInt32(state);
	size_t limit = GPBCodedInputStreamPushLimit(state, length);
	while (GPBCodedInputStreamBytesUntilLimit(state) > 0) {
	id value = [self newSingleValueFromCodedInputStream:input
	extensionRegistry:extensionRegistry
	existingValue:nil];
	[message addExtension:self value:value];
	[value release];
	}
	GPBCodedInputStreamPopLimit(state, limit);
	} else {
	id existingValue = nil;
	BOOL isRepeated = ExtensionIsRepeated(description_);
	if (!isRepeated && GPBTypeIsMessage(description_->type)) {
	existingValue = [message getExistingExtension:self];
	}
	id value = [self newSingleValueFromCodedInputStream:input
	extensionRegistry:extensionRegistry
	existingValue:existingValue];
	if (isRepeated) {
	[message addExtension:self value:value];
	} else {
	[message setExtension:self value:value];
	}
	[value release];
	}
	}

	- (void)writeValue:(id)value
	includingTagToCodedOutputStream:(GPBCodedOutputStream *)output {
	if (ExtensionIsRepeated(description_)) {
	WriteArrayIncludingTagsToCodedOutputStream(value, description_, output);
	} else {
	WriteObjectIncludingTagToCodedOutputStream(value, description_, output);
	}
	}

	- (size_t)computeSerializedSizeIncludingTag:(id)value {
	if (ExtensionIsRepeated(description_)) {
	return ComputeSerializedSizeIncludingTagOfArray(description_, value);
	} else {
	return ComputeSerializedSizeIncludingTagOfObject(description_, value);
	}
	}

	// Note that this returns a retained value intentionally.
	- (id)newSingleValueFromCodedInputStream:(GPBCodedInputStream *)input
	extensionRegistry:(GPBExtensionRegistry *)extensionRegistry
	existingValue:(GPBMessage *)existingValue {
	GPBCodedInputStreamState *state = &input->state_;
	switch (description_->type) {
	case GPBTypeBool: return [[NSNumber alloc] initWithBool:GPBCodedInputStreamReadBool(state)];
	case GPBTypeFixed32: return [[NSNumber alloc] initWithUnsignedInt:GPBCodedInputStreamReadFixed32(state)];
	case GPBTypeSFixed32: return [[NSNumber alloc] initWithInt:GPBCodedInputStreamReadSFixed32(state)];
	case GPBTypeFloat: return [[NSNumber alloc] initWithFloat:GPBCodedInputStreamReadFloat(state)];
	case GPBTypeFixed64: return [[NSNumber alloc] initWithUnsignedLongLong:GPBCodedInputStreamReadFixed64(state)];
	case GPBTypeSFixed64: return [[NSNumber alloc] initWithLongLong:GPBCodedInputStreamReadSFixed64(state)];
	case GPBTypeDouble: return [[NSNumber alloc] initWithDouble:GPBCodedInputStreamReadDouble(state)];
	case GPBTypeInt32: return [[NSNumber alloc] initWithInt:GPBCodedInputStreamReadInt32(state)];
	case GPBTypeInt64: return [[NSNumber alloc] initWithLongLong:GPBCodedInputStreamReadInt64(state)];
	case GPBTypeSInt32: return [[NSNumber alloc] initWithInt:GPBCodedInputStreamReadSInt32(state)];
	case GPBTypeSInt64: return [[NSNumber alloc] initWithLongLong:GPBCodedInputStreamReadSInt64(state)];
	case GPBTypeUInt32: return [[NSNumber alloc] initWithUnsignedInt:GPBCodedInputStreamReadUInt32(state)];
	case GPBTypeUInt64: return [[NSNumber alloc] initWithUnsignedLongLong:GPBCodedInputStreamReadUInt64(state)];
	case GPBTypeData: return GPBCodedInputStreamReadRetainedData(state);
	case GPBTypeString: return GPBCodedInputStreamReadRetainedString(state);
	case GPBTypeEnum: return [[NSNumber alloc] initWithInt:GPBCodedInputStreamReadEnum(state)];
	case GPBTypeGroup:
	case GPBTypeMessage: {
	GPBMessage *message;
	if (existingValue) {
	message = [existingValue retain];
	} else {
	GPBDescriptor *decriptor = [descriptor_.msgClass descriptor];
	message = [[decriptor.messageClass alloc] init];
	}

	if (description_->type == GPBTypeGroup) {
	[input readGroup:description_->fieldNumber
	message:message
	extensionRegistry:extensionRegistry];
	} else {
	// description_->type == GPBTypeMessage
	if (ExtensionIsWireFormat(description_)) {
	// For MessageSet fields the message length will have already been
	// read.
	[message mergeFromCodedInputStream:input
	extensionRegistry:extensionRegistry];
	} else {
	[input readMessage:message extensionRegistry:extensionRegistry];
	}
	}

	return message;
	}
	}

	return nil;
	}

	- (NSComparisonResult)compareByFieldNumber:(GPBExtensionField *)other {
	int32_t selfNumber = description_->fieldNumber;
	int32_t otherNumber = other->description_->fieldNumber;
	if (selfNumber < otherNumber) {
	return NSOrderedAscending;
	} else if (selfNumber == otherNumber) {
	return NSOrderedSame;
	} else {
	return NSOrderedDescending;
	}
	}

	@end