Thomas Van Lenten | 30650d8 | 2015-05-01 08:57:16 -0400 | [diff] [blame] | 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 "GPBUnknownFieldSet_PackagePrivate.h" |
| 32 | |
| 33 | #import "GPBCodedInputStream_PackagePrivate.h" |
| 34 | #import "GPBCodedOutputStream.h" |
Thomas Van Lenten | d846b0b | 2015-06-08 16:24:57 -0400 | [diff] [blame] | 35 | #import "GPBUnknownField_PackagePrivate.h" |
Thomas Van Lenten | 30650d8 | 2015-05-01 08:57:16 -0400 | [diff] [blame] | 36 | #import "GPBUtilities.h" |
| 37 | #import "GPBWireFormat.h" |
| 38 | |
Thomas Van Lenten | 30650d8 | 2015-05-01 08:57:16 -0400 | [diff] [blame] | 39 | #pragma mark Helpers |
| 40 | |
| 41 | static void checkNumber(int32_t number) { |
| 42 | if (number == 0) { |
| 43 | [NSException raise:NSInvalidArgumentException |
| 44 | format:@"Zero is not a valid field number."]; |
| 45 | } |
| 46 | } |
| 47 | |
| 48 | @implementation GPBUnknownFieldSet { |
| 49 | @package |
| 50 | CFMutableDictionaryRef fields_; |
| 51 | } |
| 52 | |
| 53 | static void CopyWorker(const void *key, const void *value, void *context) { |
| 54 | #pragma unused(key) |
Thomas Van Lenten | d846b0b | 2015-06-08 16:24:57 -0400 | [diff] [blame] | 55 | GPBUnknownField *field = value; |
Thomas Van Lenten | 30650d8 | 2015-05-01 08:57:16 -0400 | [diff] [blame] | 56 | GPBUnknownFieldSet *result = context; |
| 57 | |
Thomas Van Lenten | d846b0b | 2015-06-08 16:24:57 -0400 | [diff] [blame] | 58 | GPBUnknownField *copied = [field copy]; |
Thomas Van Lenten | 30650d8 | 2015-05-01 08:57:16 -0400 | [diff] [blame] | 59 | [result addField:copied]; |
| 60 | [copied release]; |
| 61 | } |
| 62 | |
Thomas Van Lenten | c8a440d | 2016-05-25 13:46:00 -0400 | [diff] [blame] | 63 | // Direct access is use for speed, to avoid even internally declaring things |
| 64 | // read/write, etc. The warning is enabled in the project to ensure code calling |
| 65 | // protos can turn on -Wdirect-ivar-access without issues. |
| 66 | #pragma clang diagnostic push |
| 67 | #pragma clang diagnostic ignored "-Wdirect-ivar-access" |
| 68 | |
Thomas Van Lenten | 30650d8 | 2015-05-01 08:57:16 -0400 | [diff] [blame] | 69 | - (id)copyWithZone:(NSZone *)zone { |
| 70 | GPBUnknownFieldSet *result = [[GPBUnknownFieldSet allocWithZone:zone] init]; |
| 71 | if (fields_) { |
| 72 | CFDictionaryApplyFunction(fields_, CopyWorker, result); |
| 73 | } |
| 74 | return result; |
| 75 | } |
| 76 | |
| 77 | - (void)dealloc { |
| 78 | if (fields_) { |
| 79 | CFRelease(fields_); |
| 80 | } |
| 81 | [super dealloc]; |
| 82 | } |
| 83 | |
| 84 | - (BOOL)isEqual:(id)object { |
| 85 | BOOL equal = NO; |
| 86 | if ([object isKindOfClass:[GPBUnknownFieldSet class]]) { |
| 87 | GPBUnknownFieldSet *set = (GPBUnknownFieldSet *)object; |
| 88 | if ((fields_ == NULL) && (set->fields_ == NULL)) { |
| 89 | equal = YES; |
| 90 | } else if ((fields_ != NULL) && (set->fields_ != NULL)) { |
| 91 | equal = CFEqual(fields_, set->fields_); |
| 92 | } |
| 93 | } |
| 94 | return equal; |
| 95 | } |
| 96 | |
| 97 | - (NSUInteger)hash { |
| 98 | // Return the hash of the fields dictionary (or just some value). |
| 99 | if (fields_) { |
| 100 | return CFHash(fields_); |
| 101 | } |
| 102 | return (NSUInteger)[GPBUnknownFieldSet class]; |
| 103 | } |
| 104 | |
| 105 | #pragma mark - Public Methods |
| 106 | |
| 107 | - (BOOL)hasField:(int32_t)number { |
| 108 | ssize_t key = number; |
| 109 | return fields_ ? (CFDictionaryGetValue(fields_, (void *)key) != nil) : NO; |
| 110 | } |
| 111 | |
Thomas Van Lenten | d846b0b | 2015-06-08 16:24:57 -0400 | [diff] [blame] | 112 | - (GPBUnknownField *)getField:(int32_t)number { |
Thomas Van Lenten | 30650d8 | 2015-05-01 08:57:16 -0400 | [diff] [blame] | 113 | ssize_t key = number; |
Thomas Van Lenten | d846b0b | 2015-06-08 16:24:57 -0400 | [diff] [blame] | 114 | GPBUnknownField *result = |
| 115 | fields_ ? CFDictionaryGetValue(fields_, (void *)key) : nil; |
Thomas Van Lenten | 30650d8 | 2015-05-01 08:57:16 -0400 | [diff] [blame] | 116 | return result; |
| 117 | } |
| 118 | |
| 119 | - (NSUInteger)countOfFields { |
| 120 | return fields_ ? CFDictionaryGetCount(fields_) : 0; |
| 121 | } |
| 122 | |
| 123 | - (NSArray *)sortedFields { |
Thomas Van Lenten | c8a440d | 2016-05-25 13:46:00 -0400 | [diff] [blame] | 124 | if (!fields_) return [NSArray array]; |
Thomas Van Lenten | 30650d8 | 2015-05-01 08:57:16 -0400 | [diff] [blame] | 125 | size_t count = CFDictionaryGetCount(fields_); |
| 126 | ssize_t keys[count]; |
Thomas Van Lenten | d846b0b | 2015-06-08 16:24:57 -0400 | [diff] [blame] | 127 | GPBUnknownField *values[count]; |
Thomas Van Lenten | 30650d8 | 2015-05-01 08:57:16 -0400 | [diff] [blame] | 128 | CFDictionaryGetKeysAndValues(fields_, (const void **)keys, |
| 129 | (const void **)values); |
| 130 | struct GPBFieldPair { |
| 131 | ssize_t key; |
Thomas Van Lenten | d846b0b | 2015-06-08 16:24:57 -0400 | [diff] [blame] | 132 | GPBUnknownField *value; |
Thomas Van Lenten | 30650d8 | 2015-05-01 08:57:16 -0400 | [diff] [blame] | 133 | } pairs[count]; |
| 134 | for (size_t i = 0; i < count; ++i) { |
| 135 | pairs[i].key = keys[i]; |
| 136 | pairs[i].value = values[i]; |
| 137 | }; |
| 138 | qsort_b(pairs, count, sizeof(struct GPBFieldPair), |
| 139 | ^(const void *first, const void *second) { |
| 140 | const struct GPBFieldPair *a = first; |
| 141 | const struct GPBFieldPair *b = second; |
| 142 | return (a->key > b->key) ? 1 : ((a->key == b->key) ? 0 : -1); |
| 143 | }); |
| 144 | for (size_t i = 0; i < count; ++i) { |
| 145 | values[i] = pairs[i].value; |
| 146 | }; |
| 147 | return [NSArray arrayWithObjects:values count:count]; |
| 148 | } |
| 149 | |
| 150 | #pragma mark - Internal Methods |
| 151 | |
| 152 | - (void)writeToCodedOutputStream:(GPBCodedOutputStream *)output { |
| 153 | if (!fields_) return; |
| 154 | size_t count = CFDictionaryGetCount(fields_); |
| 155 | ssize_t keys[count]; |
Thomas Van Lenten | d846b0b | 2015-06-08 16:24:57 -0400 | [diff] [blame] | 156 | GPBUnknownField *values[count]; |
Thomas Van Lenten | 30650d8 | 2015-05-01 08:57:16 -0400 | [diff] [blame] | 157 | CFDictionaryGetKeysAndValues(fields_, (const void **)keys, |
| 158 | (const void **)values); |
| 159 | if (count > 1) { |
| 160 | struct GPBFieldPair { |
| 161 | ssize_t key; |
Thomas Van Lenten | d846b0b | 2015-06-08 16:24:57 -0400 | [diff] [blame] | 162 | GPBUnknownField *value; |
Thomas Van Lenten | 30650d8 | 2015-05-01 08:57:16 -0400 | [diff] [blame] | 163 | } pairs[count]; |
| 164 | |
| 165 | for (size_t i = 0; i < count; ++i) { |
| 166 | pairs[i].key = keys[i]; |
| 167 | pairs[i].value = values[i]; |
| 168 | }; |
| 169 | qsort_b(pairs, count, sizeof(struct GPBFieldPair), |
| 170 | ^(const void *first, const void *second) { |
| 171 | const struct GPBFieldPair *a = first; |
| 172 | const struct GPBFieldPair *b = second; |
| 173 | return (a->key > b->key) ? 1 : ((a->key == b->key) ? 0 : -1); |
| 174 | }); |
| 175 | for (size_t i = 0; i < count; ++i) { |
Thomas Van Lenten | d846b0b | 2015-06-08 16:24:57 -0400 | [diff] [blame] | 176 | GPBUnknownField *value = pairs[i].value; |
Thomas Van Lenten | 30650d8 | 2015-05-01 08:57:16 -0400 | [diff] [blame] | 177 | [value writeToOutput:output]; |
| 178 | } |
| 179 | } else { |
| 180 | [values[0] writeToOutput:output]; |
| 181 | } |
| 182 | } |
| 183 | |
| 184 | - (NSString *)description { |
| 185 | NSMutableString *description = [NSMutableString |
| 186 | stringWithFormat:@"<%@ %p>: TextFormat: {\n", [self class], self]; |
| 187 | NSString *textFormat = GPBTextFormatForUnknownFieldSet(self, @" "); |
| 188 | [description appendString:textFormat]; |
| 189 | [description appendString:@"}"]; |
| 190 | return description; |
| 191 | } |
| 192 | |
| 193 | static void GPBUnknownFieldSetSerializedSize(const void *key, const void *value, |
| 194 | void *context) { |
| 195 | #pragma unused(key) |
Thomas Van Lenten | d846b0b | 2015-06-08 16:24:57 -0400 | [diff] [blame] | 196 | GPBUnknownField *field = value; |
Thomas Van Lenten | 30650d8 | 2015-05-01 08:57:16 -0400 | [diff] [blame] | 197 | size_t *result = context; |
| 198 | *result += [field serializedSize]; |
| 199 | } |
| 200 | |
| 201 | - (size_t)serializedSize { |
| 202 | size_t result = 0; |
| 203 | if (fields_) { |
| 204 | CFDictionaryApplyFunction(fields_, GPBUnknownFieldSetSerializedSize, |
| 205 | &result); |
| 206 | } |
| 207 | return result; |
| 208 | } |
| 209 | |
| 210 | static void GPBUnknownFieldSetWriteAsMessageSetTo(const void *key, |
| 211 | const void *value, |
| 212 | void *context) { |
| 213 | #pragma unused(key) |
Thomas Van Lenten | d846b0b | 2015-06-08 16:24:57 -0400 | [diff] [blame] | 214 | GPBUnknownField *field = value; |
Thomas Van Lenten | 30650d8 | 2015-05-01 08:57:16 -0400 | [diff] [blame] | 215 | GPBCodedOutputStream *output = context; |
| 216 | [field writeAsMessageSetExtensionToOutput:output]; |
| 217 | } |
| 218 | |
| 219 | - (void)writeAsMessageSetTo:(GPBCodedOutputStream *)output { |
| 220 | if (fields_) { |
| 221 | CFDictionaryApplyFunction(fields_, GPBUnknownFieldSetWriteAsMessageSetTo, |
| 222 | output); |
| 223 | } |
| 224 | } |
| 225 | |
| 226 | static void GPBUnknownFieldSetSerializedSizeAsMessageSet(const void *key, |
| 227 | const void *value, |
| 228 | void *context) { |
| 229 | #pragma unused(key) |
Thomas Van Lenten | d846b0b | 2015-06-08 16:24:57 -0400 | [diff] [blame] | 230 | GPBUnknownField *field = value; |
Thomas Van Lenten | 30650d8 | 2015-05-01 08:57:16 -0400 | [diff] [blame] | 231 | size_t *result = context; |
| 232 | *result += [field serializedSizeAsMessageSetExtension]; |
| 233 | } |
| 234 | |
| 235 | - (size_t)serializedSizeAsMessageSet { |
| 236 | size_t result = 0; |
| 237 | if (fields_) { |
| 238 | CFDictionaryApplyFunction( |
| 239 | fields_, GPBUnknownFieldSetSerializedSizeAsMessageSet, &result); |
| 240 | } |
| 241 | return result; |
| 242 | } |
| 243 | |
| 244 | - (NSData *)data { |
| 245 | NSMutableData *data = [NSMutableData dataWithLength:self.serializedSize]; |
| 246 | GPBCodedOutputStream *output = |
| 247 | [[GPBCodedOutputStream alloc] initWithData:data]; |
| 248 | [self writeToCodedOutputStream:output]; |
| 249 | [output release]; |
| 250 | return data; |
| 251 | } |
| 252 | |
| 253 | + (BOOL)isFieldTag:(int32_t)tag { |
| 254 | return GPBWireFormatGetTagWireType(tag) != GPBWireFormatEndGroup; |
| 255 | } |
| 256 | |
Thomas Van Lenten | d846b0b | 2015-06-08 16:24:57 -0400 | [diff] [blame] | 257 | - (void)addField:(GPBUnknownField *)field { |
Thomas Van Lenten | 30650d8 | 2015-05-01 08:57:16 -0400 | [diff] [blame] | 258 | int32_t number = [field number]; |
| 259 | checkNumber(number); |
| 260 | if (!fields_) { |
Thomas Van Lenten | 5904279 | 2016-09-19 13:07:25 -0400 | [diff] [blame] | 261 | // Use a custom dictionary here because the keys are numbers and conversion |
| 262 | // back and forth from NSNumber isn't worth the cost. |
| 263 | fields_ = CFDictionaryCreateMutable(kCFAllocatorDefault, 0, NULL, |
Thomas Van Lenten | 30650d8 | 2015-05-01 08:57:16 -0400 | [diff] [blame] | 264 | &kCFTypeDictionaryValueCallBacks); |
| 265 | } |
| 266 | ssize_t key = number; |
| 267 | CFDictionarySetValue(fields_, (const void *)key, field); |
| 268 | } |
| 269 | |
Thomas Van Lenten | d846b0b | 2015-06-08 16:24:57 -0400 | [diff] [blame] | 270 | - (GPBUnknownField *)mutableFieldForNumber:(int32_t)number create:(BOOL)create { |
Thomas Van Lenten | 30650d8 | 2015-05-01 08:57:16 -0400 | [diff] [blame] | 271 | ssize_t key = number; |
Thomas Van Lenten | d846b0b | 2015-06-08 16:24:57 -0400 | [diff] [blame] | 272 | GPBUnknownField *existing = |
Thomas Van Lenten | 30650d8 | 2015-05-01 08:57:16 -0400 | [diff] [blame] | 273 | fields_ ? CFDictionaryGetValue(fields_, (const void *)key) : nil; |
| 274 | if (!existing && create) { |
Thomas Van Lenten | d846b0b | 2015-06-08 16:24:57 -0400 | [diff] [blame] | 275 | existing = [[GPBUnknownField alloc] initWithNumber:number]; |
Thomas Van Lenten | 30650d8 | 2015-05-01 08:57:16 -0400 | [diff] [blame] | 276 | // This retains existing. |
| 277 | [self addField:existing]; |
| 278 | [existing release]; |
| 279 | } |
| 280 | return existing; |
| 281 | } |
| 282 | |
| 283 | static void GPBUnknownFieldSetMergeUnknownFields(const void *key, |
| 284 | const void *value, |
| 285 | void *context) { |
| 286 | #pragma unused(key) |
Thomas Van Lenten | d846b0b | 2015-06-08 16:24:57 -0400 | [diff] [blame] | 287 | GPBUnknownField *field = value; |
Thomas Van Lenten | 30650d8 | 2015-05-01 08:57:16 -0400 | [diff] [blame] | 288 | GPBUnknownFieldSet *self = context; |
| 289 | |
| 290 | int32_t number = [field number]; |
| 291 | checkNumber(number); |
Thomas Van Lenten | d846b0b | 2015-06-08 16:24:57 -0400 | [diff] [blame] | 292 | GPBUnknownField *oldField = [self mutableFieldForNumber:number create:NO]; |
Thomas Van Lenten | 30650d8 | 2015-05-01 08:57:16 -0400 | [diff] [blame] | 293 | if (oldField) { |
| 294 | [oldField mergeFromField:field]; |
| 295 | } else { |
| 296 | // Merge only comes from GPBMessage's mergeFrom:, so it means we are on |
| 297 | // mutable message and are an mutable instance, so make sure we need |
| 298 | // mutable fields. |
Thomas Van Lenten | d846b0b | 2015-06-08 16:24:57 -0400 | [diff] [blame] | 299 | GPBUnknownField *fieldCopy = [field copy]; |
Thomas Van Lenten | 30650d8 | 2015-05-01 08:57:16 -0400 | [diff] [blame] | 300 | [self addField:fieldCopy]; |
| 301 | [fieldCopy release]; |
| 302 | } |
| 303 | } |
| 304 | |
| 305 | - (void)mergeUnknownFields:(GPBUnknownFieldSet *)other { |
| 306 | if (other && other->fields_) { |
| 307 | CFDictionaryApplyFunction(other->fields_, |
| 308 | GPBUnknownFieldSetMergeUnknownFields, self); |
| 309 | } |
| 310 | } |
| 311 | |
| 312 | - (void)mergeFromData:(NSData *)data { |
| 313 | GPBCodedInputStream *input = [[GPBCodedInputStream alloc] initWithData:data]; |
| 314 | [self mergeFromCodedInputStream:input]; |
| 315 | [input checkLastTagWas:0]; |
| 316 | [input release]; |
| 317 | } |
| 318 | |
| 319 | - (void)mergeVarintField:(int32_t)number value:(int32_t)value { |
| 320 | checkNumber(number); |
| 321 | [[self mutableFieldForNumber:number create:YES] addVarint:value]; |
| 322 | } |
| 323 | |
| 324 | - (BOOL)mergeFieldFrom:(int32_t)tag input:(GPBCodedInputStream *)input { |
Thomas Van Lenten | c18aa77 | 2016-06-29 09:51:13 -0400 | [diff] [blame] | 325 | NSAssert(GPBWireFormatIsValidTag(tag), @"Got passed an invalid tag"); |
Thomas Van Lenten | 30650d8 | 2015-05-01 08:57:16 -0400 | [diff] [blame] | 326 | int32_t number = GPBWireFormatGetTagFieldNumber(tag); |
| 327 | GPBCodedInputStreamState *state = &input->state_; |
| 328 | switch (GPBWireFormatGetTagWireType(tag)) { |
| 329 | case GPBWireFormatVarint: { |
Thomas Van Lenten | d846b0b | 2015-06-08 16:24:57 -0400 | [diff] [blame] | 330 | GPBUnknownField *field = [self mutableFieldForNumber:number create:YES]; |
Thomas Van Lenten | 30650d8 | 2015-05-01 08:57:16 -0400 | [diff] [blame] | 331 | [field addVarint:GPBCodedInputStreamReadInt64(state)]; |
| 332 | return YES; |
| 333 | } |
| 334 | case GPBWireFormatFixed64: { |
Thomas Van Lenten | d846b0b | 2015-06-08 16:24:57 -0400 | [diff] [blame] | 335 | GPBUnknownField *field = [self mutableFieldForNumber:number create:YES]; |
Thomas Van Lenten | 30650d8 | 2015-05-01 08:57:16 -0400 | [diff] [blame] | 336 | [field addFixed64:GPBCodedInputStreamReadFixed64(state)]; |
| 337 | return YES; |
| 338 | } |
| 339 | case GPBWireFormatLengthDelimited: { |
Thomas Van Lenten | d846b0b | 2015-06-08 16:24:57 -0400 | [diff] [blame] | 340 | NSData *data = GPBCodedInputStreamReadRetainedBytes(state); |
| 341 | GPBUnknownField *field = [self mutableFieldForNumber:number create:YES]; |
Thomas Van Lenten | 30650d8 | 2015-05-01 08:57:16 -0400 | [diff] [blame] | 342 | [field addLengthDelimited:data]; |
| 343 | [data release]; |
| 344 | return YES; |
| 345 | } |
| 346 | case GPBWireFormatStartGroup: { |
| 347 | GPBUnknownFieldSet *unknownFieldSet = [[GPBUnknownFieldSet alloc] init]; |
| 348 | [input readUnknownGroup:number message:unknownFieldSet]; |
Thomas Van Lenten | d846b0b | 2015-06-08 16:24:57 -0400 | [diff] [blame] | 349 | GPBUnknownField *field = [self mutableFieldForNumber:number create:YES]; |
Thomas Van Lenten | 30650d8 | 2015-05-01 08:57:16 -0400 | [diff] [blame] | 350 | [field addGroup:unknownFieldSet]; |
| 351 | [unknownFieldSet release]; |
| 352 | return YES; |
| 353 | } |
| 354 | case GPBWireFormatEndGroup: |
| 355 | return NO; |
| 356 | case GPBWireFormatFixed32: { |
Thomas Van Lenten | d846b0b | 2015-06-08 16:24:57 -0400 | [diff] [blame] | 357 | GPBUnknownField *field = [self mutableFieldForNumber:number create:YES]; |
Thomas Van Lenten | 30650d8 | 2015-05-01 08:57:16 -0400 | [diff] [blame] | 358 | [field addFixed32:GPBCodedInputStreamReadFixed32(state)]; |
| 359 | return YES; |
| 360 | } |
| 361 | } |
| 362 | } |
| 363 | |
| 364 | - (void)mergeMessageSetMessage:(int32_t)number data:(NSData *)messageData { |
| 365 | [[self mutableFieldForNumber:number create:YES] |
| 366 | addLengthDelimited:messageData]; |
| 367 | } |
| 368 | |
| 369 | - (void)addUnknownMapEntry:(int32_t)fieldNum value:(NSData *)data { |
Thomas Van Lenten | d846b0b | 2015-06-08 16:24:57 -0400 | [diff] [blame] | 370 | GPBUnknownField *field = [self mutableFieldForNumber:fieldNum create:YES]; |
Thomas Van Lenten | 30650d8 | 2015-05-01 08:57:16 -0400 | [diff] [blame] | 371 | [field addLengthDelimited:data]; |
| 372 | } |
| 373 | |
| 374 | - (void)mergeFromCodedInputStream:(GPBCodedInputStream *)input { |
| 375 | while (YES) { |
| 376 | int32_t tag = GPBCodedInputStreamReadTag(&input->state_); |
| 377 | if (tag == 0 || ![self mergeFieldFrom:tag input:input]) { |
| 378 | break; |
| 379 | } |
| 380 | } |
| 381 | } |
| 382 | |
| 383 | - (void)getTags:(int32_t *)tags { |
| 384 | if (!fields_) return; |
| 385 | size_t count = CFDictionaryGetCount(fields_); |
| 386 | ssize_t keys[count]; |
| 387 | CFDictionaryGetKeysAndValues(fields_, (const void **)keys, NULL); |
| 388 | for (size_t i = 0; i < count; ++i) { |
| 389 | tags[i] = (int32_t)keys[i]; |
| 390 | } |
| 391 | } |
| 392 | |
Thomas Van Lenten | c8a440d | 2016-05-25 13:46:00 -0400 | [diff] [blame] | 393 | #pragma clang diagnostic pop |
| 394 | |
Thomas Van Lenten | 30650d8 | 2015-05-01 08:57:16 -0400 | [diff] [blame] | 395 | @end |