GPBCodedOutputStream.m 41 KB

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