iOS/Pods/Protobuf/objectivec/GPBCodedOutputStream.m

   1 // Protocol Buffers - Google's data interchange format
   2 // Copyright 2008 Google Inc.  All rights reserved.
   3 // https://developers.google.com/protocol-buffers/
   4 //
   5 // Redistribution and use in source and binary forms, with or without
   6 // modification, are permitted provided that the following conditions are
   7 // met:
   8 //
   9 //     * Redistributions of source code must retain the above copyright
  10 // notice, this list of conditions and the following disclaimer.
  11 //     * Redistributions in binary form must reproduce the above
  12 // copyright notice, this list of conditions and the following disclaimer
  13 // in the documentation and/or other materials provided with the
  14 // distribution.
  15 //     * Neither the name of Google Inc. nor the names of its
  16 // contributors may be used to endorse or promote products derived from
  17 // this software without specific prior written permission.
  18 //
  19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  20 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  21 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  22 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  23 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  25 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  26 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  27 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  28 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  29 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30
  31 #import "GPBCodedOutputStream_PackagePrivate.h"
  32
  33 #import <mach/vm_param.h>
  34
  35 #import "GPBArray.h"
  36 #import "GPBUnknownFieldSet_PackagePrivate.h"
  37 #import "GPBUtilities_PackagePrivate.h"
  38
  39 // These values are the existing values so as not to break any code that might
  40 // have already been inspecting them when they weren't documented/exposed.
  41 NSString *const GPBCodedOutputStreamException_OutOfSpace = @"OutOfSpace";
  42 NSString *const GPBCodedOutputStreamException_WriteFailed = @"WriteFailed";
  43
  44 // Structure for containing state of a GPBCodedInputStream. Brought out into
  45 // a struct so that we can inline several common functions instead of dealing
  46 // with overhead of ObjC dispatch.
  47 typedef struct GPBOutputBufferState {
  48   uint8_t *bytes;
  49   size_t size;
  50   size_t position;
  51   NSOutputStream *output;
  52 } GPBOutputBufferState;
  53
  54 @implementation GPBCodedOutputStream {
  55   GPBOutputBufferState state_;
  56   NSMutableData *buffer_;
  57 }
  58
  59 static const int32_t LITTLE_ENDIAN_32_SIZE = sizeof(uint32_t);
  60 static const int32_t LITTLE_ENDIAN_64_SIZE = sizeof(uint64_t);
  61
  62 // Internal helper that writes the current buffer to the output. The
  63 // buffer position is reset to its initial value when this returns.
  64 static void GPBRefreshBuffer(GPBOutputBufferState *state) {
  65   if (state->output == nil) {
  66     // We're writing to a single buffer.
  67     [NSException raise:GPBCodedOutputStreamException_OutOfSpace format:@""];
  68   }
  69   if (state->position != 0) {
  70     NSInteger written =
  71         [state->output write:state->bytes maxLength:state->position];
  72     if (written != (NSInteger)state->position) {
  73       [NSException raise:GPBCodedOutputStreamException_WriteFailed format:@""];
  74     }
  75     state->position = 0;
  76   }
  77 }
  78
  79 static void GPBWriteRawByte(GPBOutputBufferState *state, uint8_t value) {
  80   if (state->position == state->size) {
  81     GPBRefreshBuffer(state);
  82   }
  83   state->bytes[state->position++] = value;
  84 }
  85
  86 static void GPBWriteRawVarint32(GPBOutputBufferState *state, int32_t value) {
  87   while (YES) {
  88     if ((value & ~0x7F) == 0) {
  89       uint8_t val = (uint8_t)value;
  90       GPBWriteRawByte(state, val);
  91       return;
  92     } else {
  93       GPBWriteRawByte(state, (value & 0x7F) | 0x80);
  94       value = GPBLogicalRightShift32(value, 7);
  95     }
  96   }
  97 }
  98
  99 static void GPBWriteRawVarint64(GPBOutputBufferState *state, int64_t value) {
 100   while (YES) {
 101     if ((value & ~0x7FL) == 0) {
 102       uint8_t val = (uint8_t)value;
 103       GPBWriteRawByte(state, val);
 104       return;
 105     } else {
 106       GPBWriteRawByte(state, ((int32_t)value & 0x7F) | 0x80);
 107       value = GPBLogicalRightShift64(value, 7);
 108     }
 109   }
 110 }
 111
 112 static void GPBWriteInt32NoTag(GPBOutputBufferState *state, int32_t value) {
 113   if (value >= 0) {
 114     GPBWriteRawVarint32(state, value);
 115   } else {
 116     // Must sign-extend
 117     GPBWriteRawVarint64(state, value);
 118   }
 119 }
 120
 121 static void GPBWriteUInt32(GPBOutputBufferState *state, int32_t fieldNumber,
 122                            uint32_t value) {
 123   GPBWriteTagWithFormat(state, fieldNumber, GPBWireFormatVarint);
 124   GPBWriteRawVarint32(state, value);
 125 }
 126
 127 static void GPBWriteTagWithFormat(GPBOutputBufferState *state,
 128                                   uint32_t fieldNumber, GPBWireFormat format) {
 129   GPBWriteRawVarint32(state, GPBWireFormatMakeTag(fieldNumber, format));
 130 }
 131
 132 static void GPBWriteRawLittleEndian32(GPBOutputBufferState *state,
 133                                       int32_t value) {
 134   GPBWriteRawByte(state, (value)&0xFF);
 135   GPBWriteRawByte(state, (value >> 8) & 0xFF);
 136   GPBWriteRawByte(state, (value >> 16) & 0xFF);
 137   GPBWriteRawByte(state, (value >> 24) & 0xFF);
 138 }
 139
 140 static void GPBWriteRawLittleEndian64(GPBOutputBufferState *state,
 141                                       int64_t value) {
 142   GPBWriteRawByte(state, (int32_t)(value)&0xFF);
 143   GPBWriteRawByte(state, (int32_t)(value >> 8) & 0xFF);
 144   GPBWriteRawByte(state, (int32_t)(value >> 16) & 0xFF);
 145   GPBWriteRawByte(state, (int32_t)(value >> 24) & 0xFF);
 146   GPBWriteRawByte(state, (int32_t)(value >> 32) & 0xFF);
 147   GPBWriteRawByte(state, (int32_t)(value >> 40) & 0xFF);
 148   GPBWriteRawByte(state, (int32_t)(value >> 48) & 0xFF);
 149   GPBWriteRawByte(state, (int32_t)(value >> 56) & 0xFF);
 150 }
 151
 152 - (void)dealloc {
 153   [self flush];
 154   [state_.output close];
 155   [state_.output release];
 156   [buffer_ release];
 157
 158   [super dealloc];
 159 }
 160
 161 - (instancetype)initWithOutputStream:(NSOutputStream *)output {
 162   NSMutableData *data = [NSMutableData dataWithLength:PAGE_SIZE];
 163   return [self initWithOutputStream:output data:data];
 164 }
 165
 166 - (instancetype)initWithData:(NSMutableData *)data {
 167   return [self initWithOutputStream:nil data:data];
 168 }
 169
 170 // This initializer isn't exposed, but it is the designated initializer.
 171 // Setting OutputStream and NSData is to control the buffering behavior/size
 172 // of the work, but that is more obvious via the bufferSize: version.
 173 - (instancetype)initWithOutputStream:(NSOutputStream *)output
 174                                 data:(NSMutableData *)data {
 175   if ((self = [super init])) {
 176     buffer_ = [data retain];
 177     state_.bytes = [data mutableBytes];
 178     state_.size = [data length];
 179     state_.output = [output retain];
 180     [state_.output open];
 181   }
 182   return self;
 183 }
 184
 185 + (instancetype)streamWithOutputStream:(NSOutputStream *)output {
 186   NSMutableData *data = [NSMutableData dataWithLength:PAGE_SIZE];
 187   return [[[self alloc] initWithOutputStream:output
 188                                         data:data] autorelease];
 189 }
 190
 191 + (instancetype)streamWithData:(NSMutableData *)data {
 192   return [[[self alloc] initWithData:data] autorelease];
 193 }
 194
 195 // Direct access is use for speed, to avoid even internally declaring things
 196 // read/write, etc. The warning is enabled in the project to ensure code calling
 197 // protos can turn on -Wdirect-ivar-access without issues.
 198 #pragma clang diagnostic push
 199 #pragma clang diagnostic ignored "-Wdirect-ivar-access"
 200
 201 - (void)writeDoubleNoTag:(double)value {
 202   GPBWriteRawLittleEndian64(&state_, GPBConvertDoubleToInt64(value));
 203 }
 204
 205 - (void)writeDouble:(int32_t)fieldNumber value:(double)value {
 206   GPBWriteTagWithFormat(&state_, fieldNumber, GPBWireFormatFixed64);
 207   GPBWriteRawLittleEndian64(&state_, GPBConvertDoubleToInt64(value));
 208 }
 209
 210 - (void)writeFloatNoTag:(float)value {
 211   GPBWriteRawLittleEndian32(&state_, GPBConvertFloatToInt32(value));
 212 }
 213
 214 - (void)writeFloat:(int32_t)fieldNumber value:(float)value {
 215   GPBWriteTagWithFormat(&state_, fieldNumber, GPBWireFormatFixed32);
 216   GPBWriteRawLittleEndian32(&state_, GPBConvertFloatToInt32(value));
 217 }
 218
 219 - (void)writeUInt64NoTag:(uint64_t)value {
 220   GPBWriteRawVarint64(&state_, value);
 221 }
 222
 223 - (void)writeUInt64:(int32_t)fieldNumber value:(uint64_t)value {
 224   GPBWriteTagWithFormat(&state_, fieldNumber, GPBWireFormatVarint);
 225   GPBWriteRawVarint64(&state_, value);
 226 }
 227
 228 - (void)writeInt64NoTag:(int64_t)value {
 229   GPBWriteRawVarint64(&state_, value);
 230 }
 231
 232 - (void)writeInt64:(int32_t)fieldNumber value:(int64_t)value {
 233   GPBWriteTagWithFormat(&state_, fieldNumber, GPBWireFormatVarint);
 234   GPBWriteRawVarint64(&state_, value);
 235 }
 236
 237 - (void)writeInt32NoTag:(int32_t)value {
 238   GPBWriteInt32NoTag(&state_, value);
 239 }
 240
 241 - (void)writeInt32:(int32_t)fieldNumber value:(int32_t)value {
 242   GPBWriteTagWithFormat(&state_, fieldNumber, GPBWireFormatVarint);
 243   GPBWriteInt32NoTag(&state_, value);
 244 }
 245
 246 - (void)writeFixed64NoTag:(uint64_t)value {
 247   GPBWriteRawLittleEndian64(&state_, value);
 248 }
 249
 250 - (void)writeFixed64:(int32_t)fieldNumber value:(uint64_t)value {
 251   GPBWriteTagWithFormat(&state_, fieldNumber, GPBWireFormatFixed64);
 252   GPBWriteRawLittleEndian64(&state_, value);
 253 }
 254
 255 - (void)writeFixed32NoTag:(uint32_t)value {
 256   GPBWriteRawLittleEndian32(&state_, value);
 257 }
 258
 259 - (void)writeFixed32:(int32_t)fieldNumber value:(uint32_t)value {
 260   GPBWriteTagWithFormat(&state_, fieldNumber, GPBWireFormatFixed32);
 261   GPBWriteRawLittleEndian32(&state_, value);
 262 }
 263
 264 - (void)writeBoolNoTag:(BOOL)value {
 265   GPBWriteRawByte(&state_, (value ? 1 : 0));
 266 }
 267
 268 - (void)writeBool:(int32_t)fieldNumber value:(BOOL)value {
 269   GPBWriteTagWithFormat(&state_, fieldNumber, GPBWireFormatVarint);
 270   GPBWriteRawByte(&state_, (value ? 1 : 0));
 271 }
 272
 273 - (void)writeStringNoTag:(const NSString *)value {
 274   size_t length = [value lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
 275   GPBWriteRawVarint32(&state_, (int32_t)length);
 276   if (length == 0) {
 277     return;
 278   }
 279
 280   const char *quickString =
 281       CFStringGetCStringPtr((CFStringRef)value, kCFStringEncodingUTF8);
 282
 283   // Fast path: Most strings are short, if the buffer already has space,
 284   // add to it directly.
 285   NSUInteger bufferBytesLeft = state_.size - state_.position;
 286   if (bufferBytesLeft >= length) {
 287     NSUInteger usedBufferLength = 0;
 288     BOOL result;
 289     if (quickString != NULL) {
 290       memcpy(state_.bytes + state_.position, quickString, length);
 291       usedBufferLength = length;
 292       result = YES;
 293     } else {
 294       result = [value getBytes:state_.bytes + state_.position
 295                      maxLength:bufferBytesLeft
 296                     usedLength:&usedBufferLength
 297                       encoding:NSUTF8StringEncoding
 298                        options:(NSStringEncodingConversionOptions)0
 299                          range:NSMakeRange(0, [value length])
 300                 remainingRange:NULL];
 301     }
 302     if (result) {
 303       NSAssert2((usedBufferLength == length),
 304                 @"Our UTF8 calc was wrong? %tu vs %zd", usedBufferLength,
 305                 length);
 306       state_.position += usedBufferLength;
 307       return;
 308     }
 309   } else if (quickString != NULL) {
 310     [self writeRawPtr:quickString offset:0 length:length];
 311   } else {
 312     // Slow path: just get it as data and write it out.
 313     NSData *utf8Data = [value dataUsingEncoding:NSUTF8StringEncoding];
 314     NSAssert2(([utf8Data length] == length),
 315               @"Strings UTF8 length was wrong? %tu vs %zd", [utf8Data length],
 316               length);
 317     [self writeRawData:utf8Data];
 318   }
 319 }
 320
 321 - (void)writeString:(int32_t)fieldNumber value:(NSString *)value {
 322   GPBWriteTagWithFormat(&state_, fieldNumber, GPBWireFormatLengthDelimited);
 323   [self writeStringNoTag:value];
 324 }
 325
 326 - (void)writeGroupNoTag:(int32_t)fieldNumber value:(GPBMessage *)value {
 327   [value writeToCodedOutputStream:self];
 328   GPBWriteTagWithFormat(&state_, fieldNumber, GPBWireFormatEndGroup);
 329 }
 330
 331 - (void)writeGroup:(int32_t)fieldNumber value:(GPBMessage *)value {
 332   GPBWriteTagWithFormat(&state_, fieldNumber, GPBWireFormatStartGroup);
 333   [self writeGroupNoTag:fieldNumber value:value];
 334 }
 335
 336 - (void)writeUnknownGroupNoTag:(int32_t)fieldNumber
 337                          value:(const GPBUnknownFieldSet *)value {
 338   [value writeToCodedOutputStream:self];
 339   GPBWriteTagWithFormat(&state_, fieldNumber, GPBWireFormatEndGroup);
 340 }
 341
 342 - (void)writeUnknownGroup:(int32_t)fieldNumber
 343                     value:(GPBUnknownFieldSet *)value {
 344   GPBWriteTagWithFormat(&state_, fieldNumber, GPBWireFormatStartGroup);
 345   [self writeUnknownGroupNoTag:fieldNumber value:value];
 346 }
 347
 348 - (void)writeMessageNoTag:(GPBMessage *)value {
 349   GPBWriteRawVarint32(&state_, (int32_t)[value serializedSize]);
 350   [value writeToCodedOutputStream:self];
 351 }
 352
 353 - (void)writeMessage:(int32_t)fieldNumber value:(GPBMessage *)value {
 354   GPBWriteTagWithFormat(&state_, fieldNumber, GPBWireFormatLengthDelimited);
 355   [self writeMessageNoTag:value];
 356 }
 357
 358 - (void)writeBytesNoTag:(NSData *)value {
 359   GPBWriteRawVarint32(&state_, (int32_t)[value length]);
 360   [self writeRawData:value];
 361 }
 362
 363 - (void)writeBytes:(int32_t)fieldNumber value:(NSData *)value {
 364   GPBWriteTagWithFormat(&state_, fieldNumber, GPBWireFormatLengthDelimited);
 365   [self writeBytesNoTag:value];
 366 }
 367
 368 - (void)writeUInt32NoTag:(uint32_t)value {
 369   GPBWriteRawVarint32(&state_, value);
 370 }
 371
 372 - (void)writeUInt32:(int32_t)fieldNumber value:(uint32_t)value {
 373   GPBWriteUInt32(&state_, fieldNumber, value);
 374 }
 375
 376 - (void)writeEnumNoTag:(int32_t)value {
 377   GPBWriteRawVarint32(&state_, value);
 378 }
 379
 380 - (void)writeEnum:(int32_t)fieldNumber value:(int32_t)value {
 381   GPBWriteTagWithFormat(&state_, fieldNumber, GPBWireFormatVarint);
 382   GPBWriteRawVarint32(&state_, value);
 383 }
 384
 385 - (void)writeSFixed32NoTag:(int32_t)value {
 386   GPBWriteRawLittleEndian32(&state_, value);
 387 }
 388
 389 - (void)writeSFixed32:(int32_t)fieldNumber value:(int32_t)value {
 390   GPBWriteTagWithFormat(&state_, fieldNumber, GPBWireFormatFixed32);
 391   GPBWriteRawLittleEndian32(&state_, value);
 392 }
 393
 394 - (void)writeSFixed64NoTag:(int64_t)value {
 395   GPBWriteRawLittleEndian64(&state_, value);
 396 }
 397
 398 - (void)writeSFixed64:(int32_t)fieldNumber value:(int64_t)value {
 399   GPBWriteTagWithFormat(&state_, fieldNumber, GPBWireFormatFixed64);
 400   GPBWriteRawLittleEndian64(&state_, value);
 401 }
 402
 403 - (void)writeSInt32NoTag:(int32_t)value {
 404   GPBWriteRawVarint32(&state_, GPBEncodeZigZag32(value));
 405 }
 406
 407 - (void)writeSInt32:(int32_t)fieldNumber value:(int32_t)value {
 408   GPBWriteTagWithFormat(&state_, fieldNumber, GPBWireFormatVarint);
 409   GPBWriteRawVarint32(&state_, GPBEncodeZigZag32(value));
 410 }
 411
 412 - (void)writeSInt64NoTag:(int64_t)value {
 413   GPBWriteRawVarint64(&state_, GPBEncodeZigZag64(value));
 414 }
 415
 416 - (void)writeSInt64:(int32_t)fieldNumber value:(int64_t)value {
 417   GPBWriteTagWithFormat(&state_, fieldNumber, GPBWireFormatVarint);
 418   GPBWriteRawVarint64(&state_, GPBEncodeZigZag64(value));
 419 }
 420
 421 //%PDDM-DEFINE WRITE_PACKABLE_DEFNS(NAME, ARRAY_TYPE, TYPE, ACCESSOR_NAME)
 422 //%- (void)write##NAME##Array:(int32_t)fieldNumber
 423 //%       NAME$S     values:(GPB##ARRAY_TYPE##Array *)values
 424 //%       NAME$S        tag:(uint32_t)tag {
 425 //%  if (tag != 0) {
 426 //%    if (values.count == 0) return;
 427 //%    __block size_t dataSize = 0;
 428 //%    [values enumerate##ACCESSOR_NAME##ValuesWithBlock:^(TYPE value, NSUInteger idx, BOOL *stop) {
 429 //%#pragma unused(idx, stop)
 430 //%      dataSize += GPBCompute##NAME##SizeNoTag(value);
 431 //%    }];
 432 //%    GPBWriteRawVarint32(&state_, tag);
 433 //%    GPBWriteRawVarint32(&state_, (int32_t)dataSize);
 434 //%    [values enumerate##ACCESSOR_NAME##ValuesWithBlock:^(TYPE value, NSUInteger idx, BOOL *stop) {
 435 //%#pragma unused(idx, stop)
 436 //%      [self write##NAME##NoTag:value];
 437 //%    }];
 438 //%  } else {
 439 //%    [values enumerate##ACCESSOR_NAME##ValuesWithBlock:^(TYPE value, NSUInteger idx, BOOL *stop) {
 440 //%#pragma unused(idx, stop)
 441 //%      [self write##NAME:fieldNumber value:value];
 442 //%    }];
 443 //%  }
 444 //%}
 445 //%
 446 //%PDDM-DEFINE WRITE_UNPACKABLE_DEFNS(NAME, TYPE)
 447 //%- (void)write##NAME##Array:(int32_t)fieldNumber values:(NSArray *)values {
 448 //%  for (TYPE *value in values) {
 449 //%    [self write##NAME:fieldNumber value:value];
 450 //%  }
 451 //%}
 452 //%
 453 //%PDDM-EXPAND WRITE_PACKABLE_DEFNS(Double, Double, double, )
 454 // This block of code is generated, do not edit it directly.
 455
 456 - (void)writeDoubleArray:(int32_t)fieldNumber
 457                   values:(GPBDoubleArray *)values
 458                      tag:(uint32_t)tag {
 459   if (tag != 0) {
 460     if (values.count == 0) return;
 461     __block size_t dataSize = 0;
 462     [values enumerateValuesWithBlock:^(double value, NSUInteger idx, BOOL *stop) {
 463 #pragma unused(idx, stop)
 464       dataSize += GPBComputeDoubleSizeNoTag(value);
 465     }];
 466     GPBWriteRawVarint32(&state_, tag);
 467     GPBWriteRawVarint32(&state_, (int32_t)dataSize);
 468     [values enumerateValuesWithBlock:^(double value, NSUInteger idx, BOOL *stop) {
 469 #pragma unused(idx, stop)
 470       [self writeDoubleNoTag:value];
 471     }];
 472   } else {
 473     [values enumerateValuesWithBlock:^(double value, NSUInteger idx, BOOL *stop) {
 474 #pragma unused(idx, stop)
 475       [self writeDouble:fieldNumber value:value];
 476     }];
 477   }
 478 }
 479
 480 //%PDDM-EXPAND WRITE_PACKABLE_DEFNS(Float, Float, float, )
 481 // This block of code is generated, do not edit it directly.
 482
 483 - (void)writeFloatArray:(int32_t)fieldNumber
 484                  values:(GPBFloatArray *)values
 485                     tag:(uint32_t)tag {
 486   if (tag != 0) {
 487     if (values.count == 0) return;
 488     __block size_t dataSize = 0;
 489     [values enumerateValuesWithBlock:^(float value, NSUInteger idx, BOOL *stop) {
 490 #pragma unused(idx, stop)
 491       dataSize += GPBComputeFloatSizeNoTag(value);
 492     }];
 493     GPBWriteRawVarint32(&state_, tag);
 494     GPBWriteRawVarint32(&state_, (int32_t)dataSize);
 495     [values enumerateValuesWithBlock:^(float value, NSUInteger idx, BOOL *stop) {
 496 #pragma unused(idx, stop)
 497       [self writeFloatNoTag:value];
 498     }];
 499   } else {
 500     [values enumerateValuesWithBlock:^(float value, NSUInteger idx, BOOL *stop) {
 501 #pragma unused(idx, stop)
 502       [self writeFloat:fieldNumber value:value];
 503     }];
 504   }
 505 }
 506
 507 //%PDDM-EXPAND WRITE_PACKABLE_DEFNS(UInt64, UInt64, uint64_t, )
 508 // This block of code is generated, do not edit it directly.
 509
 510 - (void)writeUInt64Array:(int32_t)fieldNumber
 511                   values:(GPBUInt64Array *)values
 512                      tag:(uint32_t)tag {
 513   if (tag != 0) {
 514     if (values.count == 0) return;
 515     __block size_t dataSize = 0;
 516     [values enumerateValuesWithBlock:^(uint64_t value, NSUInteger idx, BOOL *stop) {
 517 #pragma unused(idx, stop)
 518       dataSize += GPBComputeUInt64SizeNoTag(value);
 519     }];
 520     GPBWriteRawVarint32(&state_, tag);
 521     GPBWriteRawVarint32(&state_, (int32_t)dataSize);
 522     [values enumerateValuesWithBlock:^(uint64_t value, NSUInteger idx, BOOL *stop) {
 523 #pragma unused(idx, stop)
 524       [self writeUInt64NoTag:value];
 525     }];
 526   } else {
 527     [values enumerateValuesWithBlock:^(uint64_t value, NSUInteger idx, BOOL *stop) {
 528 #pragma unused(idx, stop)
 529       [self writeUInt64:fieldNumber value:value];
 530     }];
 531   }
 532 }
 533
 534 //%PDDM-EXPAND WRITE_PACKABLE_DEFNS(Int64, Int64, int64_t, )
 535 // This block of code is generated, do not edit it directly.
 536
 537 - (void)writeInt64Array:(int32_t)fieldNumber
 538                  values:(GPBInt64Array *)values
 539                     tag:(uint32_t)tag {
 540   if (tag != 0) {
 541     if (values.count == 0) return;
 542     __block size_t dataSize = 0;
 543     [values enumerateValuesWithBlock:^(int64_t value, NSUInteger idx, BOOL *stop) {
 544 #pragma unused(idx, stop)
 545       dataSize += GPBComputeInt64SizeNoTag(value);
 546     }];
 547     GPBWriteRawVarint32(&state_, tag);
 548     GPBWriteRawVarint32(&state_, (int32_t)dataSize);
 549     [values enumerateValuesWithBlock:^(int64_t value, NSUInteger idx, BOOL *stop) {
 550 #pragma unused(idx, stop)
 551       [self writeInt64NoTag:value];
 552     }];
 553   } else {
 554     [values enumerateValuesWithBlock:^(int64_t value, NSUInteger idx, BOOL *stop) {
 555 #pragma unused(idx, stop)
 556       [self writeInt64:fieldNumber value:value];
 557     }];
 558   }
 559 }
 560
 561 //%PDDM-EXPAND WRITE_PACKABLE_DEFNS(Int32, Int32, int32_t, )
 562 // This block of code is generated, do not edit it directly.
 563
 564 - (void)writeInt32Array:(int32_t)fieldNumber
 565                  values:(GPBInt32Array *)values
 566                     tag:(uint32_t)tag {
 567   if (tag != 0) {
 568     if (values.count == 0) return;
 569     __block size_t dataSize = 0;
 570     [values enumerateValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
 571 #pragma unused(idx, stop)
 572       dataSize += GPBComputeInt32SizeNoTag(value);
 573     }];
 574     GPBWriteRawVarint32(&state_, tag);
 575     GPBWriteRawVarint32(&state_, (int32_t)dataSize);
 576     [values enumerateValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
 577 #pragma unused(idx, stop)
 578       [self writeInt32NoTag:value];
 579     }];
 580   } else {
 581     [values enumerateValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
 582 #pragma unused(idx, stop)
 583       [self writeInt32:fieldNumber value:value];
 584     }];
 585   }
 586 }
 587
 588 //%PDDM-EXPAND WRITE_PACKABLE_DEFNS(UInt32, UInt32, uint32_t, )
 589 // This block of code is generated, do not edit it directly.
 590
 591 - (void)writeUInt32Array:(int32_t)fieldNumber
 592                   values:(GPBUInt32Array *)values
 593                      tag:(uint32_t)tag {
 594   if (tag != 0) {
 595     if (values.count == 0) return;
 596     __block size_t dataSize = 0;
 597     [values enumerateValuesWithBlock:^(uint32_t value, NSUInteger idx, BOOL *stop) {
 598 #pragma unused(idx, stop)
 599       dataSize += GPBComputeUInt32SizeNoTag(value);
 600     }];
 601     GPBWriteRawVarint32(&state_, tag);
 602     GPBWriteRawVarint32(&state_, (int32_t)dataSize);
 603     [values enumerateValuesWithBlock:^(uint32_t value, NSUInteger idx, BOOL *stop) {
 604 #pragma unused(idx, stop)
 605       [self writeUInt32NoTag:value];
 606     }];
 607   } else {
 608     [values enumerateValuesWithBlock:^(uint32_t value, NSUInteger idx, BOOL *stop) {
 609 #pragma unused(idx, stop)
 610       [self writeUInt32:fieldNumber value:value];
 611     }];
 612   }
 613 }
 614
 615 //%PDDM-EXPAND WRITE_PACKABLE_DEFNS(Fixed64, UInt64, uint64_t, )
 616 // This block of code is generated, do not edit it directly.
 617
 618 - (void)writeFixed64Array:(int32_t)fieldNumber
 619                    values:(GPBUInt64Array *)values
 620                       tag:(uint32_t)tag {
 621   if (tag != 0) {
 622     if (values.count == 0) return;
 623     __block size_t dataSize = 0;
 624     [values enumerateValuesWithBlock:^(uint64_t value, NSUInteger idx, BOOL *stop) {
 625 #pragma unused(idx, stop)
 626       dataSize += GPBComputeFixed64SizeNoTag(value);
 627     }];
 628     GPBWriteRawVarint32(&state_, tag);
 629     GPBWriteRawVarint32(&state_, (int32_t)dataSize);
 630     [values enumerateValuesWithBlock:^(uint64_t value, NSUInteger idx, BOOL *stop) {
 631 #pragma unused(idx, stop)
 632       [self writeFixed64NoTag:value];
 633     }];
 634   } else {
 635     [values enumerateValuesWithBlock:^(uint64_t value, NSUInteger idx, BOOL *stop) {
 636 #pragma unused(idx, stop)
 637       [self writeFixed64:fieldNumber value:value];
 638     }];
 639   }
 640 }
 641
 642 //%PDDM-EXPAND WRITE_PACKABLE_DEFNS(Fixed32, UInt32, uint32_t, )
 643 // This block of code is generated, do not edit it directly.
 644
 645 - (void)writeFixed32Array:(int32_t)fieldNumber
 646                    values:(GPBUInt32Array *)values
 647                       tag:(uint32_t)tag {
 648   if (tag != 0) {
 649     if (values.count == 0) return;
 650     __block size_t dataSize = 0;
 651     [values enumerateValuesWithBlock:^(uint32_t value, NSUInteger idx, BOOL *stop) {
 652 #pragma unused(idx, stop)
 653       dataSize += GPBComputeFixed32SizeNoTag(value);
 654     }];
 655     GPBWriteRawVarint32(&state_, tag);
 656     GPBWriteRawVarint32(&state_, (int32_t)dataSize);
 657     [values enumerateValuesWithBlock:^(uint32_t value, NSUInteger idx, BOOL *stop) {
 658 #pragma unused(idx, stop)
 659       [self writeFixed32NoTag:value];
 660     }];
 661   } else {
 662     [values enumerateValuesWithBlock:^(uint32_t value, NSUInteger idx, BOOL *stop) {
 663 #pragma unused(idx, stop)
 664       [self writeFixed32:fieldNumber value:value];
 665     }];
 666   }
 667 }
 668
 669 //%PDDM-EXPAND WRITE_PACKABLE_DEFNS(SInt32, Int32, int32_t, )
 670 // This block of code is generated, do not edit it directly.
 671
 672 - (void)writeSInt32Array:(int32_t)fieldNumber
 673                   values:(GPBInt32Array *)values
 674                      tag:(uint32_t)tag {
 675   if (tag != 0) {
 676     if (values.count == 0) return;
 677     __block size_t dataSize = 0;
 678     [values enumerateValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
 679 #pragma unused(idx, stop)
 680       dataSize += GPBComputeSInt32SizeNoTag(value);
 681     }];
 682     GPBWriteRawVarint32(&state_, tag);
 683     GPBWriteRawVarint32(&state_, (int32_t)dataSize);
 684     [values enumerateValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
 685 #pragma unused(idx, stop)
 686       [self writeSInt32NoTag:value];
 687     }];
 688   } else {
 689     [values enumerateValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
 690 #pragma unused(idx, stop)
 691       [self writeSInt32:fieldNumber value:value];
 692     }];
 693   }
 694 }
 695
 696 //%PDDM-EXPAND WRITE_PACKABLE_DEFNS(SInt64, Int64, int64_t, )
 697 // This block of code is generated, do not edit it directly.
 698
 699 - (void)writeSInt64Array:(int32_t)fieldNumber
 700                   values:(GPBInt64Array *)values
 701                      tag:(uint32_t)tag {
 702   if (tag != 0) {
 703     if (values.count == 0) return;
 704     __block size_t dataSize = 0;
 705     [values enumerateValuesWithBlock:^(int64_t value, NSUInteger idx, BOOL *stop) {
 706 #pragma unused(idx, stop)
 707       dataSize += GPBComputeSInt64SizeNoTag(value);
 708     }];
 709     GPBWriteRawVarint32(&state_, tag);
 710     GPBWriteRawVarint32(&state_, (int32_t)dataSize);
 711     [values enumerateValuesWithBlock:^(int64_t value, NSUInteger idx, BOOL *stop) {
 712 #pragma unused(idx, stop)
 713       [self writeSInt64NoTag:value];
 714     }];
 715   } else {
 716     [values enumerateValuesWithBlock:^(int64_t value, NSUInteger idx, BOOL *stop) {
 717 #pragma unused(idx, stop)
 718       [self writeSInt64:fieldNumber value:value];
 719     }];
 720   }
 721 }
 722
 723 //%PDDM-EXPAND WRITE_PACKABLE_DEFNS(SFixed64, Int64, int64_t, )
 724 // This block of code is generated, do not edit it directly.
 725
 726 - (void)writeSFixed64Array:(int32_t)fieldNumber
 727                     values:(GPBInt64Array *)values
 728                        tag:(uint32_t)tag {
 729   if (tag != 0) {
 730     if (values.count == 0) return;
 731     __block size_t dataSize = 0;
 732     [values enumerateValuesWithBlock:^(int64_t value, NSUInteger idx, BOOL *stop) {
 733 #pragma unused(idx, stop)
 734       dataSize += GPBComputeSFixed64SizeNoTag(value);
 735     }];
 736     GPBWriteRawVarint32(&state_, tag);
 737     GPBWriteRawVarint32(&state_, (int32_t)dataSize);
 738     [values enumerateValuesWithBlock:^(int64_t value, NSUInteger idx, BOOL *stop) {
 739 #pragma unused(idx, stop)
 740       [self writeSFixed64NoTag:value];
 741     }];
 742   } else {
 743     [values enumerateValuesWithBlock:^(int64_t value, NSUInteger idx, BOOL *stop) {
 744 #pragma unused(idx, stop)
 745       [self writeSFixed64:fieldNumber value:value];
 746     }];
 747   }
 748 }
 749
 750 //%PDDM-EXPAND WRITE_PACKABLE_DEFNS(SFixed32, Int32, int32_t, )
 751 // This block of code is generated, do not edit it directly.
 752
 753 - (void)writeSFixed32Array:(int32_t)fieldNumber
 754                     values:(GPBInt32Array *)values
 755                        tag:(uint32_t)tag {
 756   if (tag != 0) {
 757     if (values.count == 0) return;
 758     __block size_t dataSize = 0;
 759     [values enumerateValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
 760 #pragma unused(idx, stop)
 761       dataSize += GPBComputeSFixed32SizeNoTag(value);
 762     }];
 763     GPBWriteRawVarint32(&state_, tag);
 764     GPBWriteRawVarint32(&state_, (int32_t)dataSize);
 765     [values enumerateValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
 766 #pragma unused(idx, stop)
 767       [self writeSFixed32NoTag:value];
 768     }];
 769   } else {
 770     [values enumerateValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
 771 #pragma unused(idx, stop)
 772       [self writeSFixed32:fieldNumber value:value];
 773     }];
 774   }
 775 }
 776
 777 //%PDDM-EXPAND WRITE_PACKABLE_DEFNS(Bool, Bool, BOOL, )
 778 // This block of code is generated, do not edit it directly.
 779
 780 - (void)writeBoolArray:(int32_t)fieldNumber
 781                 values:(GPBBoolArray *)values
 782                    tag:(uint32_t)tag {
 783   if (tag != 0) {
 784     if (values.count == 0) return;
 785     __block size_t dataSize = 0;
 786     [values enumerateValuesWithBlock:^(BOOL value, NSUInteger idx, BOOL *stop) {
 787 #pragma unused(idx, stop)
 788       dataSize += GPBComputeBoolSizeNoTag(value);
 789     }];
 790     GPBWriteRawVarint32(&state_, tag);
 791     GPBWriteRawVarint32(&state_, (int32_t)dataSize);
 792     [values enumerateValuesWithBlock:^(BOOL value, NSUInteger idx, BOOL *stop) {
 793 #pragma unused(idx, stop)
 794       [self writeBoolNoTag:value];
 795     }];
 796   } else {
 797     [values enumerateValuesWithBlock:^(BOOL value, NSUInteger idx, BOOL *stop) {
 798 #pragma unused(idx, stop)
 799       [self writeBool:fieldNumber value:value];
 800     }];
 801   }
 802 }
 803
 804 //%PDDM-EXPAND WRITE_PACKABLE_DEFNS(Enum, Enum, int32_t, Raw)
 805 // This block of code is generated, do not edit it directly.
 806
 807 - (void)writeEnumArray:(int32_t)fieldNumber
 808                 values:(GPBEnumArray *)values
 809                    tag:(uint32_t)tag {
 810   if (tag != 0) {
 811     if (values.count == 0) return;
 812     __block size_t dataSize = 0;
 813     [values enumerateRawValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
 814 #pragma unused(idx, stop)
 815       dataSize += GPBComputeEnumSizeNoTag(value);
 816     }];
 817     GPBWriteRawVarint32(&state_, tag);
 818     GPBWriteRawVarint32(&state_, (int32_t)dataSize);
 819     [values enumerateRawValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
 820 #pragma unused(idx, stop)
 821       [self writeEnumNoTag:value];
 822     }];
 823   } else {
 824     [values enumerateRawValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
 825 #pragma unused(idx, stop)
 826       [self writeEnum:fieldNumber value:value];
 827     }];
 828   }
 829 }
 830
 831 //%PDDM-EXPAND WRITE_UNPACKABLE_DEFNS(String, NSString)
 832 // This block of code is generated, do not edit it directly.
 833
 834 - (void)writeStringArray:(int32_t)fieldNumber values:(NSArray *)values {
 835   for (NSString *value in values) {
 836     [self writeString:fieldNumber value:value];
 837   }
 838 }
 839
 840 //%PDDM-EXPAND WRITE_UNPACKABLE_DEFNS(Message, GPBMessage)
 841 // This block of code is generated, do not edit it directly.
 842
 843 - (void)writeMessageArray:(int32_t)fieldNumber values:(NSArray *)values {
 844   for (GPBMessage *value in values) {
 845     [self writeMessage:fieldNumber value:value];
 846   }
 847 }
 848
 849 //%PDDM-EXPAND WRITE_UNPACKABLE_DEFNS(Bytes, NSData)
 850 // This block of code is generated, do not edit it directly.
 851
 852 - (void)writeBytesArray:(int32_t)fieldNumber values:(NSArray *)values {
 853   for (NSData *value in values) {
 854     [self writeBytes:fieldNumber value:value];
 855   }
 856 }
 857
 858 //%PDDM-EXPAND WRITE_UNPACKABLE_DEFNS(Group, GPBMessage)
 859 // This block of code is generated, do not edit it directly.
 860
 861 - (void)writeGroupArray:(int32_t)fieldNumber values:(NSArray *)values {
 862   for (GPBMessage *value in values) {
 863     [self writeGroup:fieldNumber value:value];
 864   }
 865 }
 866
 867 //%PDDM-EXPAND WRITE_UNPACKABLE_DEFNS(UnknownGroup, GPBUnknownFieldSet)
 868 // This block of code is generated, do not edit it directly.
 869
 870 - (void)writeUnknownGroupArray:(int32_t)fieldNumber values:(NSArray *)values {
 871   for (GPBUnknownFieldSet *value in values) {
 872     [self writeUnknownGroup:fieldNumber value:value];
 873   }
 874 }
 875
 876 //%PDDM-EXPAND-END (19 expansions)
 877
 878 - (void)writeMessageSetExtension:(int32_t)fieldNumber
 879                            value:(GPBMessage *)value {
 880   GPBWriteTagWithFormat(&state_, GPBWireFormatMessageSetItem,
 881                         GPBWireFormatStartGroup);
 882   GPBWriteUInt32(&state_, GPBWireFormatMessageSetTypeId, fieldNumber);
 883   [self writeMessage:GPBWireFormatMessageSetMessage value:value];
 884   GPBWriteTagWithFormat(&state_, GPBWireFormatMessageSetItem,
 885                         GPBWireFormatEndGroup);
 886 }
 887
 888 - (void)writeRawMessageSetExtension:(int32_t)fieldNumber value:(NSData *)value {
 889   GPBWriteTagWithFormat(&state_, GPBWireFormatMessageSetItem,
 890                         GPBWireFormatStartGroup);
 891   GPBWriteUInt32(&state_, GPBWireFormatMessageSetTypeId, fieldNumber);
 892   [self writeBytes:GPBWireFormatMessageSetMessage value:value];
 893   GPBWriteTagWithFormat(&state_, GPBWireFormatMessageSetItem,
 894                         GPBWireFormatEndGroup);
 895 }
 896
 897 - (void)flush {
 898   if (state_.output != nil) {
 899     GPBRefreshBuffer(&state_);
 900   }
 901 }
 902
 903 - (void)writeRawByte:(uint8_t)value {
 904   GPBWriteRawByte(&state_, value);
 905 }
 906
 907 - (void)writeRawData:(const NSData *)data {
 908   [self writeRawPtr:[data bytes] offset:0 length:[data length]];
 909 }
 910
 911 - (void)writeRawPtr:(const void *)value
 912              offset:(size_t)offset
 913              length:(size_t)length {
 914   if (value == nil || length == 0) {
 915     return;
 916   }
 917
 918   NSUInteger bufferLength = state_.size;
 919   NSUInteger bufferBytesLeft = bufferLength - state_.position;
 920   if (bufferBytesLeft >= length) {
 921     // We have room in the current buffer.
 922     memcpy(state_.bytes + state_.position, ((uint8_t *)value) + offset, length);
 923     state_.position += length;
 924   } else {
 925     // Write extends past current buffer.  Fill the rest of this buffer and
 926     // flush.
 927     size_t bytesWritten = bufferBytesLeft;
 928     memcpy(state_.bytes + state_.position, ((uint8_t *)value) + offset,
 929            bytesWritten);
 930     offset += bytesWritten;
 931     length -= bytesWritten;
 932     state_.position = bufferLength;
 933     GPBRefreshBuffer(&state_);
 934     bufferLength = state_.size;
 935
 936     // Now deal with the rest.
 937     // Since we have an output stream, this is our buffer
 938     // and buffer offset == 0
 939     if (length <= bufferLength) {
 940       // Fits in new buffer.
 941       memcpy(state_.bytes, ((uint8_t *)value) + offset, length);
 942       state_.position = length;
 943     } else {
 944       // Write is very big.  Let's do it all at once.
 945       NSInteger written = [state_.output write:((uint8_t *)value) + offset maxLength:length];
 946       if (written != (NSInteger)length) {
 947         [NSException raise:GPBCodedOutputStreamException_WriteFailed format:@""];
 948       }
 949     }
 950   }
 951 }
 952
 953 - (void)writeTag:(uint32_t)fieldNumber format:(GPBWireFormat)format {
 954   GPBWriteTagWithFormat(&state_, fieldNumber, format);
 955 }
 956
 957 - (void)writeRawVarint32:(int32_t)value {
 958   GPBWriteRawVarint32(&state_, value);
 959 }
 960
 961 - (void)writeRawVarintSizeTAs32:(size_t)value {
 962   // Note the truncation.
 963   GPBWriteRawVarint32(&state_, (int32_t)value);
 964 }
 965
 966 - (void)writeRawVarint64:(int64_t)value {
 967   GPBWriteRawVarint64(&state_, value);
 968 }
 969
 970 - (void)writeRawLittleEndian32:(int32_t)value {
 971   GPBWriteRawLittleEndian32(&state_, value);
 972 }
 973
 974 - (void)writeRawLittleEndian64:(int64_t)value {
 975   GPBWriteRawLittleEndian64(&state_, value);
 976 }
 977
 978 #pragma clang diagnostic pop
 979
 980 @end
 981
 982 size_t GPBComputeDoubleSizeNoTag(Float64 value) {
 983 #pragma unused(value)
 984   return LITTLE_ENDIAN_64_SIZE;
 985 }
 986
 987 size_t GPBComputeFloatSizeNoTag(Float32 value) {
 988 #pragma unused(value)
 989   return LITTLE_ENDIAN_32_SIZE;
 990 }
 991
 992 size_t GPBComputeUInt64SizeNoTag(uint64_t value) {
 993   return GPBComputeRawVarint64Size(value);
 994 }
 995
 996 size_t GPBComputeInt64SizeNoTag(int64_t value) {
 997   return GPBComputeRawVarint64Size(value);
 998 }
 999
1000 size_t GPBComputeInt32SizeNoTag(int32_t value) {
1001   if (value >= 0) {
1002     return GPBComputeRawVarint32Size(value);
1003   } else {
1004     // Must sign-extend.
1005     return 10;
1006   }
1007 }
1008
1009 size_t GPBComputeSizeTSizeAsInt32NoTag(size_t value) {
1010   return GPBComputeInt32SizeNoTag((int32_t)value);
1011 }
1012
1013 size_t GPBComputeFixed64SizeNoTag(uint64_t value) {
1014 #pragma unused(value)
1015   return LITTLE_ENDIAN_64_SIZE;
1016 }
1017
1018 size_t GPBComputeFixed32SizeNoTag(uint32_t value) {
1019 #pragma unused(value)
1020   return LITTLE_ENDIAN_32_SIZE;
1021 }
1022
1023 size_t GPBComputeBoolSizeNoTag(BOOL value) {
1024 #pragma unused(value)
1025   return 1;
1026 }
1027
1028 size_t GPBComputeStringSizeNoTag(NSString *value) {
1029   NSUInteger length = [value lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
1030   return GPBComputeRawVarint32SizeForInteger(length) + length;
1031 }
1032
1033 size_t GPBComputeGroupSizeNoTag(GPBMessage *value) {
1034   return [value serializedSize];
1035 }
1036
1037 size_t GPBComputeUnknownGroupSizeNoTag(GPBUnknownFieldSet *value) {
1038   return value.serializedSize;
1039 }
1040
1041 size_t GPBComputeMessageSizeNoTag(GPBMessage *value) {
1042   size_t size = [value serializedSize];
1043   return GPBComputeRawVarint32SizeForInteger(size) + size;
1044 }
1045
1046 size_t GPBComputeBytesSizeNoTag(NSData *value) {
1047   NSUInteger valueLength = [value length];
1048   return GPBComputeRawVarint32SizeForInteger(valueLength) + valueLength;
1049 }
1050
1051 size_t GPBComputeUInt32SizeNoTag(int32_t value) {
1052   return GPBComputeRawVarint32Size(value);
1053 }
1054
1055 size_t GPBComputeEnumSizeNoTag(int32_t value) {
1056   return GPBComputeRawVarint32Size(value);
1057 }
1058
1059 size_t GPBComputeSFixed32SizeNoTag(int32_t value) {
1060 #pragma unused(value)
1061   return LITTLE_ENDIAN_32_SIZE;
1062 }
1063
1064 size_t GPBComputeSFixed64SizeNoTag(int64_t value) {
1065 #pragma unused(value)
1066   return LITTLE_ENDIAN_64_SIZE;
1067 }
1068
1069 size_t GPBComputeSInt32SizeNoTag(int32_t value) {
1070   return GPBComputeRawVarint32Size(GPBEncodeZigZag32(value));
1071 }
1072
1073 size_t GPBComputeSInt64SizeNoTag(int64_t value) {
1074   return GPBComputeRawVarint64Size(GPBEncodeZigZag64(value));
1075 }
1076
1077 size_t GPBComputeDoubleSize(int32_t fieldNumber, double value) {
1078   return GPBComputeTagSize(fieldNumber) + GPBComputeDoubleSizeNoTag(value);
1079 }
1080
1081 size_t GPBComputeFloatSize(int32_t fieldNumber, float value) {
1082   return GPBComputeTagSize(fieldNumber) + GPBComputeFloatSizeNoTag(value);
1083 }
1084
1085 size_t GPBComputeUInt64Size(int32_t fieldNumber, uint64_t value) {
1086   return GPBComputeTagSize(fieldNumber) + GPBComputeUInt64SizeNoTag(value);
1087 }
1088
1089 size_t GPBComputeInt64Size(int32_t fieldNumber, int64_t value) {
1090   return GPBComputeTagSize(fieldNumber) + GPBComputeInt64SizeNoTag(value);
1091 }
1092
1093 size_t GPBComputeInt32Size(int32_t fieldNumber, int32_t value) {
1094   return GPBComputeTagSize(fieldNumber) + GPBComputeInt32SizeNoTag(value);
1095 }
1096
1097 size_t GPBComputeFixed64Size(int32_t fieldNumber, uint64_t value) {
1098   return GPBComputeTagSize(fieldNumber) + GPBComputeFixed64SizeNoTag(value);
1099 }
1100
1101 size_t GPBComputeFixed32Size(int32_t fieldNumber, uint32_t value) {
1102   return GPBComputeTagSize(fieldNumber) + GPBComputeFixed32SizeNoTag(value);
1103 }
1104
1105 size_t GPBComputeBoolSize(int32_t fieldNumber, BOOL value) {
1106   return GPBComputeTagSize(fieldNumber) + GPBComputeBoolSizeNoTag(value);
1107 }
1108
1109 size_t GPBComputeStringSize(int32_t fieldNumber, NSString *value) {
1110   return GPBComputeTagSize(fieldNumber) + GPBComputeStringSizeNoTag(value);
1111 }
1112
1113 size_t GPBComputeGroupSize(int32_t fieldNumber, GPBMessage *value) {
1114   return GPBComputeTagSize(fieldNumber) * 2 + GPBComputeGroupSizeNoTag(value);
1115 }
1116
1117 size_t GPBComputeUnknownGroupSize(int32_t fieldNumber,
1118                                   GPBUnknownFieldSet *value) {
1119   return GPBComputeTagSize(fieldNumber) * 2 +
1120          GPBComputeUnknownGroupSizeNoTag(value);
1121 }
1122
1123 size_t GPBComputeMessageSize(int32_t fieldNumber, GPBMessage *value) {
1124   return GPBComputeTagSize(fieldNumber) + GPBComputeMessageSizeNoTag(value);
1125 }
1126
1127 size_t GPBComputeBytesSize(int32_t fieldNumber, NSData *value) {
1128   return GPBComputeTagSize(fieldNumber) + GPBComputeBytesSizeNoTag(value);
1129 }
1130
1131 size_t GPBComputeUInt32Size(int32_t fieldNumber, uint32_t value) {
1132   return GPBComputeTagSize(fieldNumber) + GPBComputeUInt32SizeNoTag(value);
1133 }
1134
1135 size_t GPBComputeEnumSize(int32_t fieldNumber, int32_t value) {
1136   return GPBComputeTagSize(fieldNumber) + GPBComputeEnumSizeNoTag(value);
1137 }
1138
1139 size_t GPBComputeSFixed32Size(int32_t fieldNumber, int32_t value) {
1140   return GPBComputeTagSize(fieldNumber) + GPBComputeSFixed32SizeNoTag(value);
1141 }
1142
1143 size_t GPBComputeSFixed64Size(int32_t fieldNumber, int64_t value) {
1144   return GPBComputeTagSize(fieldNumber) + GPBComputeSFixed64SizeNoTag(value);
1145 }
1146
1147 size_t GPBComputeSInt32Size(int32_t fieldNumber, int32_t value) {
1148   return GPBComputeTagSize(fieldNumber) + GPBComputeSInt32SizeNoTag(value);
1149 }
1150
1151 size_t GPBComputeSInt64Size(int32_t fieldNumber, int64_t value) {
1152   return GPBComputeTagSize(fieldNumber) +
1153          GPBComputeRawVarint64Size(GPBEncodeZigZag64(value));
1154 }
1155
1156 size_t GPBComputeMessageSetExtensionSize(int32_t fieldNumber,
1157                                          GPBMessage *value) {
1158   return GPBComputeTagSize(GPBWireFormatMessageSetItem) * 2 +
1159          GPBComputeUInt32Size(GPBWireFormatMessageSetTypeId, fieldNumber) +
1160          GPBComputeMessageSize(GPBWireFormatMessageSetMessage, value);
1161 }
1162
1163 size_t GPBComputeRawMessageSetExtensionSize(int32_t fieldNumber,
1164                                             NSData *value) {
1165   return GPBComputeTagSize(GPBWireFormatMessageSetItem) * 2 +
1166          GPBComputeUInt32Size(GPBWireFormatMessageSetTypeId, fieldNumber) +
1167          GPBComputeBytesSize(GPBWireFormatMessageSetMessage, value);
1168 }
1169
1170 size_t GPBComputeTagSize(int32_t fieldNumber) {
1171   return GPBComputeRawVarint32Size(
1172       GPBWireFormatMakeTag(fieldNumber, GPBWireFormatVarint));
1173 }
1174
1175 size_t GPBComputeWireFormatTagSize(int field_number, GPBDataType dataType) {
1176   size_t result = GPBComputeTagSize(field_number);
1177   if (dataType == GPBDataTypeGroup) {
1178     // Groups have both a start and an end tag.
1179     return result * 2;
1180   } else {
1181     return result;
1182   }
1183 }
1184
1185 size_t GPBComputeRawVarint32Size(int32_t value) {
1186   // value is treated as unsigned, so it won't be sign-extended if negative.
1187   if ((value & (0xffffffff << 7)) == 0) return 1;
1188   if ((value & (0xffffffff << 14)) == 0) return 2;
1189   if ((value & (0xffffffff << 21)) == 0) return 3;
1190   if ((value & (0xffffffff << 28)) == 0) return 4;
1191   return 5;
1192 }
1193
1194 size_t GPBComputeRawVarint32SizeForInteger(NSInteger value) {
1195   // Note the truncation.
1196   return GPBComputeRawVarint32Size((int32_t)value);
1197 }
1198
1199 size_t GPBComputeRawVarint64Size(int64_t value) {
1200   if ((value & (0xffffffffffffffffL << 7)) == 0) return 1;
1201   if ((value & (0xffffffffffffffffL << 14)) == 0) return 2;
1202   if ((value & (0xffffffffffffffffL << 21)) == 0) return 3;
1203   if ((value & (0xffffffffffffffffL << 28)) == 0) return 4;
1204   if ((value & (0xffffffffffffffffL << 35)) == 0) return 5;
1205   if ((value & (0xffffffffffffffffL << 42)) == 0) return 6;
1206   if ((value & (0xffffffffffffffffL << 49)) == 0) return 7;
1207   if ((value & (0xffffffffffffffffL << 56)) == 0) return 8;
1208   if ((value & (0xffffffffffffffffL << 63)) == 0) return 9;
1209   return 10;
1210 }