iOS/Pods/Protobuf/objectivec/GPBUnknownField.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 "GPBUnknownField_PackagePrivate.h"
  32
  33 #import "GPBArray.h"
  34 #import "GPBCodedOutputStream_PackagePrivate.h"
  35
  36 @implementation GPBUnknownField {
  37  @protected
  38   int32_t number_;
  39   GPBUInt64Array *mutableVarintList_;
  40   GPBUInt32Array *mutableFixed32List_;
  41   GPBUInt64Array *mutableFixed64List_;
  42   NSMutableArray<NSData*> *mutableLengthDelimitedList_;
  43   NSMutableArray<GPBUnknownFieldSet*> *mutableGroupList_;
  44 }
  45
  46 @synthesize number = number_;
  47 @synthesize varintList = mutableVarintList_;
  48 @synthesize fixed32List = mutableFixed32List_;
  49 @synthesize fixed64List = mutableFixed64List_;
  50 @synthesize lengthDelimitedList = mutableLengthDelimitedList_;
  51 @synthesize groupList = mutableGroupList_;
  52
  53 - (instancetype)initWithNumber:(int32_t)number {
  54   if ((self = [super init])) {
  55     number_ = number;
  56   }
  57   return self;
  58 }
  59
  60 - (void)dealloc {
  61   [mutableVarintList_ release];
  62   [mutableFixed32List_ release];
  63   [mutableFixed64List_ release];
  64   [mutableLengthDelimitedList_ release];
  65   [mutableGroupList_ release];
  66
  67   [super dealloc];
  68 }
  69
  70 // Direct access is use for speed, to avoid even internally declaring things
  71 // read/write, etc. The warning is enabled in the project to ensure code calling
  72 // protos can turn on -Wdirect-ivar-access without issues.
  73 #pragma clang diagnostic push
  74 #pragma clang diagnostic ignored "-Wdirect-ivar-access"
  75
  76 - (id)copyWithZone:(NSZone *)zone {
  77   GPBUnknownField *result =
  78       [[GPBUnknownField allocWithZone:zone] initWithNumber:number_];
  79   result->mutableFixed32List_ = [mutableFixed32List_ copyWithZone:zone];
  80   result->mutableFixed64List_ = [mutableFixed64List_ copyWithZone:zone];
  81   result->mutableLengthDelimitedList_ =
  82       [mutableLengthDelimitedList_ mutableCopyWithZone:zone];
  83   result->mutableVarintList_ = [mutableVarintList_ copyWithZone:zone];
  84   if (mutableGroupList_.count) {
  85     result->mutableGroupList_ = [[NSMutableArray allocWithZone:zone]
  86         initWithCapacity:mutableGroupList_.count];
  87     for (GPBUnknownFieldSet *group in mutableGroupList_) {
  88       GPBUnknownFieldSet *copied = [group copyWithZone:zone];
  89       [result->mutableGroupList_ addObject:copied];
  90       [copied release];
  91     }
  92   }
  93   return result;
  94 }
  95
  96 - (BOOL)isEqual:(id)object {
  97   if (self == object) return YES;
  98   if (![object isKindOfClass:[GPBUnknownField class]]) return NO;
  99   GPBUnknownField *field = (GPBUnknownField *)object;
 100   if (number_ != field->number_) return NO;
 101   BOOL equalVarint =
 102       (mutableVarintList_.count == 0 && field->mutableVarintList_.count == 0) ||
 103       [mutableVarintList_ isEqual:field->mutableVarintList_];
 104   if (!equalVarint) return NO;
 105   BOOL equalFixed32 = (mutableFixed32List_.count == 0 &&
 106                        field->mutableFixed32List_.count == 0) ||
 107                       [mutableFixed32List_ isEqual:field->mutableFixed32List_];
 108   if (!equalFixed32) return NO;
 109   BOOL equalFixed64 = (mutableFixed64List_.count == 0 &&
 110                        field->mutableFixed64List_.count == 0) ||
 111                       [mutableFixed64List_ isEqual:field->mutableFixed64List_];
 112   if (!equalFixed64) return NO;
 113   BOOL equalLDList =
 114       (mutableLengthDelimitedList_.count == 0 &&
 115        field->mutableLengthDelimitedList_.count == 0) ||
 116       [mutableLengthDelimitedList_ isEqual:field->mutableLengthDelimitedList_];
 117   if (!equalLDList) return NO;
 118   BOOL equalGroupList =
 119       (mutableGroupList_.count == 0 && field->mutableGroupList_.count == 0) ||
 120       [mutableGroupList_ isEqual:field->mutableGroupList_];
 121   if (!equalGroupList) return NO;
 122   return YES;
 123 }
 124
 125 - (NSUInteger)hash {
 126   // Just mix the hashes of the possible sub arrays.
 127   const int prime = 31;
 128   NSUInteger result = prime + [mutableVarintList_ hash];
 129   result = prime * result + [mutableFixed32List_ hash];
 130   result = prime * result + [mutableFixed64List_ hash];
 131   result = prime * result + [mutableLengthDelimitedList_ hash];
 132   result = prime * result + [mutableGroupList_ hash];
 133   return result;
 134 }
 135
 136 - (void)writeToOutput:(GPBCodedOutputStream *)output {
 137   NSUInteger count = mutableVarintList_.count;
 138   if (count > 0) {
 139     [output writeUInt64Array:number_ values:mutableVarintList_ tag:0];
 140   }
 141   count = mutableFixed32List_.count;
 142   if (count > 0) {
 143     [output writeFixed32Array:number_ values:mutableFixed32List_ tag:0];
 144   }
 145   count = mutableFixed64List_.count;
 146   if (count > 0) {
 147     [output writeFixed64Array:number_ values:mutableFixed64List_ tag:0];
 148   }
 149   count = mutableLengthDelimitedList_.count;
 150   if (count > 0) {
 151     [output writeBytesArray:number_ values:mutableLengthDelimitedList_];
 152   }
 153   count = mutableGroupList_.count;
 154   if (count > 0) {
 155     [output writeUnknownGroupArray:number_ values:mutableGroupList_];
 156   }
 157 }
 158
 159 - (size_t)serializedSize {
 160   __block size_t result = 0;
 161   int32_t number = number_;
 162   [mutableVarintList_
 163       enumerateValuesWithBlock:^(uint64_t value, NSUInteger idx, BOOL *stop) {
 164 #pragma unused(idx, stop)
 165         result += GPBComputeUInt64Size(number, value);
 166       }];
 167
 168   [mutableFixed32List_
 169       enumerateValuesWithBlock:^(uint32_t value, NSUInteger idx, BOOL *stop) {
 170 #pragma unused(idx, stop)
 171         result += GPBComputeFixed32Size(number, value);
 172       }];
 173
 174   [mutableFixed64List_
 175       enumerateValuesWithBlock:^(uint64_t value, NSUInteger idx, BOOL *stop) {
 176 #pragma unused(idx, stop)
 177         result += GPBComputeFixed64Size(number, value);
 178       }];
 179
 180   for (NSData *data in mutableLengthDelimitedList_) {
 181     result += GPBComputeBytesSize(number, data);
 182   }
 183
 184   for (GPBUnknownFieldSet *set in mutableGroupList_) {
 185     result += GPBComputeUnknownGroupSize(number, set);
 186   }
 187
 188   return result;
 189 }
 190
 191 - (void)writeAsMessageSetExtensionToOutput:(GPBCodedOutputStream *)output {
 192   for (NSData *data in mutableLengthDelimitedList_) {
 193     [output writeRawMessageSetExtension:number_ value:data];
 194   }
 195 }
 196
 197 - (size_t)serializedSizeAsMessageSetExtension {
 198   size_t result = 0;
 199   for (NSData *data in mutableLengthDelimitedList_) {
 200     result += GPBComputeRawMessageSetExtensionSize(number_, data);
 201   }
 202   return result;
 203 }
 204
 205 - (NSString *)description {
 206   NSMutableString *description =
 207       [NSMutableString stringWithFormat:@"<%@ %p>: Field: %d {\n",
 208        [self class], self, number_];
 209   [mutableVarintList_
 210       enumerateValuesWithBlock:^(uint64_t value, NSUInteger idx, BOOL *stop) {
 211 #pragma unused(idx, stop)
 212         [description appendFormat:@"\t%llu\n", value];
 213       }];
 214
 215   [mutableFixed32List_
 216       enumerateValuesWithBlock:^(uint32_t value, NSUInteger idx, BOOL *stop) {
 217 #pragma unused(idx, stop)
 218         [description appendFormat:@"\t%u\n", value];
 219       }];
 220
 221   [mutableFixed64List_
 222       enumerateValuesWithBlock:^(uint64_t value, NSUInteger idx, BOOL *stop) {
 223 #pragma unused(idx, stop)
 224         [description appendFormat:@"\t%llu\n", value];
 225       }];
 226
 227   for (NSData *data in mutableLengthDelimitedList_) {
 228     [description appendFormat:@"\t%@\n", data];
 229   }
 230
 231   for (GPBUnknownFieldSet *set in mutableGroupList_) {
 232     [description appendFormat:@"\t%@\n", set];
 233   }
 234   [description appendString:@"}"];
 235   return description;
 236 }
 237
 238 - (void)mergeFromField:(GPBUnknownField *)other {
 239   GPBUInt64Array *otherVarintList = other.varintList;
 240   if (otherVarintList.count > 0) {
 241     if (mutableVarintList_ == nil) {
 242       mutableVarintList_ = [otherVarintList copy];
 243     } else {
 244       [mutableVarintList_ addValuesFromArray:otherVarintList];
 245     }
 246   }
 247
 248   GPBUInt32Array *otherFixed32List = other.fixed32List;
 249   if (otherFixed32List.count > 0) {
 250     if (mutableFixed32List_ == nil) {
 251       mutableFixed32List_ = [otherFixed32List copy];
 252     } else {
 253       [mutableFixed32List_ addValuesFromArray:otherFixed32List];
 254     }
 255   }
 256
 257   GPBUInt64Array *otherFixed64List = other.fixed64List;
 258   if (otherFixed64List.count > 0) {
 259     if (mutableFixed64List_ == nil) {
 260       mutableFixed64List_ = [otherFixed64List copy];
 261     } else {
 262       [mutableFixed64List_ addValuesFromArray:otherFixed64List];
 263     }
 264   }
 265
 266   NSArray *otherLengthDelimitedList = other.lengthDelimitedList;
 267   if (otherLengthDelimitedList.count > 0) {
 268     if (mutableLengthDelimitedList_ == nil) {
 269       mutableLengthDelimitedList_ = [otherLengthDelimitedList mutableCopy];
 270     } else {
 271       [mutableLengthDelimitedList_
 272           addObjectsFromArray:otherLengthDelimitedList];
 273     }
 274   }
 275
 276   NSArray *otherGroupList = other.groupList;
 277   if (otherGroupList.count > 0) {
 278     if (mutableGroupList_ == nil) {
 279       mutableGroupList_ =
 280           [[NSMutableArray alloc] initWithCapacity:otherGroupList.count];
 281     }
 282     // Make our own mutable copies.
 283     for (GPBUnknownFieldSet *group in otherGroupList) {
 284       GPBUnknownFieldSet *copied = [group copy];
 285       [mutableGroupList_ addObject:copied];
 286       [copied release];
 287     }
 288   }
 289 }
 290
 291 - (void)addVarint:(uint64_t)value {
 292   if (mutableVarintList_ == nil) {
 293     mutableVarintList_ = [[GPBUInt64Array alloc] initWithValues:&value count:1];
 294   } else {
 295     [mutableVarintList_ addValue:value];
 296   }
 297 }
 298
 299 - (void)addFixed32:(uint32_t)value {
 300   if (mutableFixed32List_ == nil) {
 301     mutableFixed32List_ =
 302         [[GPBUInt32Array alloc] initWithValues:&value count:1];
 303   } else {
 304     [mutableFixed32List_ addValue:value];
 305   }
 306 }
 307
 308 - (void)addFixed64:(uint64_t)value {
 309   if (mutableFixed64List_ == nil) {
 310     mutableFixed64List_ =
 311         [[GPBUInt64Array alloc] initWithValues:&value count:1];
 312   } else {
 313     [mutableFixed64List_ addValue:value];
 314   }
 315 }
 316
 317 - (void)addLengthDelimited:(NSData *)value {
 318   if (mutableLengthDelimitedList_ == nil) {
 319     mutableLengthDelimitedList_ =
 320         [[NSMutableArray alloc] initWithObjects:&value count:1];
 321   } else {
 322     [mutableLengthDelimitedList_ addObject:value];
 323   }
 324 }
 325
 326 - (void)addGroup:(GPBUnknownFieldSet *)value {
 327   if (mutableGroupList_ == nil) {
 328     mutableGroupList_ = [[NSMutableArray alloc] initWithObjects:&value count:1];
 329   } else {
 330     [mutableGroupList_ addObject:value];
 331   }
 332 }
 333
 334 #pragma clang diagnostic pop
 335
 336 @end