iOS/Pods/Protobuf/objectivec/GPBExtensionInternals.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 "GPBExtensionInternals.h"
  32
  33 #import <objc/runtime.h>
  34
  35 #import "GPBCodedInputStream_PackagePrivate.h"
  36 #import "GPBCodedOutputStream_PackagePrivate.h"
  37 #import "GPBDescriptor_PackagePrivate.h"
  38 #import "GPBMessage_PackagePrivate.h"
  39 #import "GPBUtilities_PackagePrivate.h"
  40
  41 static id NewSingleValueFromInputStream(GPBExtensionDescriptor *extension,
  42                                         GPBCodedInputStream *input,
  43                                         GPBExtensionRegistry *extensionRegistry,
  44                                         GPBMessage *existingValue)
  45     __attribute__((ns_returns_retained));
  46
  47 GPB_INLINE size_t DataTypeSize(GPBDataType dataType) {
  48 #pragma clang diagnostic push
  49 #pragma clang diagnostic ignored "-Wswitch-enum"
  50   switch (dataType) {
  51     case GPBDataTypeBool:
  52       return 1;
  53     case GPBDataTypeFixed32:
  54     case GPBDataTypeSFixed32:
  55     case GPBDataTypeFloat:
  56       return 4;
  57     case GPBDataTypeFixed64:
  58     case GPBDataTypeSFixed64:
  59     case GPBDataTypeDouble:
  60       return 8;
  61     default:
  62       return 0;
  63   }
  64 #pragma clang diagnostic pop
  65 }
  66
  67 static size_t ComputePBSerializedSizeNoTagOfObject(GPBDataType dataType, id object) {
  68 #define FIELD_CASE(TYPE, ACCESSOR)                                     \
  69   case GPBDataType##TYPE:                                              \
  70     return GPBCompute##TYPE##SizeNoTag([(NSNumber *)object ACCESSOR]);
  71 #define FIELD_CASE2(TYPE)                                              \
  72   case GPBDataType##TYPE:                                              \
  73     return GPBCompute##TYPE##SizeNoTag(object);
  74   switch (dataType) {
  75     FIELD_CASE(Bool, boolValue)
  76     FIELD_CASE(Float, floatValue)
  77     FIELD_CASE(Double, doubleValue)
  78     FIELD_CASE(Int32, intValue)
  79     FIELD_CASE(SFixed32, intValue)
  80     FIELD_CASE(SInt32, intValue)
  81     FIELD_CASE(Enum, intValue)
  82     FIELD_CASE(Int64, longLongValue)
  83     FIELD_CASE(SInt64, longLongValue)
  84     FIELD_CASE(SFixed64, longLongValue)
  85     FIELD_CASE(UInt32, unsignedIntValue)
  86     FIELD_CASE(Fixed32, unsignedIntValue)
  87     FIELD_CASE(UInt64, unsignedLongLongValue)
  88     FIELD_CASE(Fixed64, unsignedLongLongValue)
  89     FIELD_CASE2(Bytes)
  90     FIELD_CASE2(String)
  91     FIELD_CASE2(Message)
  92     FIELD_CASE2(Group)
  93   }
  94 #undef FIELD_CASE
  95 #undef FIELD_CASE2
  96 }
  97
  98 static size_t ComputeSerializedSizeIncludingTagOfObject(
  99     GPBExtensionDescription *description, id object) {
 100 #define FIELD_CASE(TYPE, ACCESSOR)                                   \
 101   case GPBDataType##TYPE:                                            \
 102     return GPBCompute##TYPE##Size(description->fieldNumber,          \
 103                                   [(NSNumber *)object ACCESSOR]);
 104 #define FIELD_CASE2(TYPE)                                            \
 105   case GPBDataType##TYPE:                                            \
 106     return GPBCompute##TYPE##Size(description->fieldNumber, object);
 107   switch (description->dataType) {
 108     FIELD_CASE(Bool, boolValue)
 109     FIELD_CASE(Float, floatValue)
 110     FIELD_CASE(Double, doubleValue)
 111     FIELD_CASE(Int32, intValue)
 112     FIELD_CASE(SFixed32, intValue)
 113     FIELD_CASE(SInt32, intValue)
 114     FIELD_CASE(Enum, intValue)
 115     FIELD_CASE(Int64, longLongValue)
 116     FIELD_CASE(SInt64, longLongValue)
 117     FIELD_CASE(SFixed64, longLongValue)
 118     FIELD_CASE(UInt32, unsignedIntValue)
 119     FIELD_CASE(Fixed32, unsignedIntValue)
 120     FIELD_CASE(UInt64, unsignedLongLongValue)
 121     FIELD_CASE(Fixed64, unsignedLongLongValue)
 122     FIELD_CASE2(Bytes)
 123     FIELD_CASE2(String)
 124     FIELD_CASE2(Group)
 125     case GPBDataTypeMessage:
 126       if (GPBExtensionIsWireFormat(description)) {
 127         return GPBComputeMessageSetExtensionSize(description->fieldNumber,
 128                                                  object);
 129       } else {
 130         return GPBComputeMessageSize(description->fieldNumber, object);
 131       }
 132   }
 133 #undef FIELD_CASE
 134 #undef FIELD_CASE2
 135 }
 136
 137 static size_t ComputeSerializedSizeIncludingTagOfArray(
 138     GPBExtensionDescription *description, NSArray *values) {
 139   if (GPBExtensionIsPacked(description)) {
 140     size_t size = 0;
 141     size_t typeSize = DataTypeSize(description->dataType);
 142     if (typeSize != 0) {
 143       size = values.count * typeSize;
 144     } else {
 145       for (id value in values) {
 146         size +=
 147             ComputePBSerializedSizeNoTagOfObject(description->dataType, value);
 148       }
 149     }
 150     return size + GPBComputeTagSize(description->fieldNumber) +
 151            GPBComputeRawVarint32SizeForInteger(size);
 152   } else {
 153     size_t size = 0;
 154     for (id value in values) {
 155       size += ComputeSerializedSizeIncludingTagOfObject(description, value);
 156     }
 157     return size;
 158   }
 159 }
 160
 161 static void WriteObjectIncludingTagToCodedOutputStream(
 162     id object, GPBExtensionDescription *description,
 163     GPBCodedOutputStream *output) {
 164 #define FIELD_CASE(TYPE, ACCESSOR)                      \
 165   case GPBDataType##TYPE:                               \
 166     [output write##TYPE:description->fieldNumber        \
 167                   value:[(NSNumber *)object ACCESSOR]]; \
 168     return;
 169 #define FIELD_CASE2(TYPE)                                       \
 170   case GPBDataType##TYPE:                                       \
 171     [output write##TYPE:description->fieldNumber value:object]; \
 172     return;
 173   switch (description->dataType) {
 174     FIELD_CASE(Bool, boolValue)
 175     FIELD_CASE(Float, floatValue)
 176     FIELD_CASE(Double, doubleValue)
 177     FIELD_CASE(Int32, intValue)
 178     FIELD_CASE(SFixed32, intValue)
 179     FIELD_CASE(SInt32, intValue)
 180     FIELD_CASE(Enum, intValue)
 181     FIELD_CASE(Int64, longLongValue)
 182     FIELD_CASE(SInt64, longLongValue)
 183     FIELD_CASE(SFixed64, longLongValue)
 184     FIELD_CASE(UInt32, unsignedIntValue)
 185     FIELD_CASE(Fixed32, unsignedIntValue)
 186     FIELD_CASE(UInt64, unsignedLongLongValue)
 187     FIELD_CASE(Fixed64, unsignedLongLongValue)
 188     FIELD_CASE2(Bytes)
 189     FIELD_CASE2(String)
 190     FIELD_CASE2(Group)
 191     case GPBDataTypeMessage:
 192       if (GPBExtensionIsWireFormat(description)) {
 193         [output writeMessageSetExtension:description->fieldNumber value:object];
 194       } else {
 195         [output writeMessage:description->fieldNumber value:object];
 196       }
 197       return;
 198   }
 199 #undef FIELD_CASE
 200 #undef FIELD_CASE2
 201 }
 202
 203 static void WriteObjectNoTagToCodedOutputStream(
 204     id object, GPBExtensionDescription *description,
 205     GPBCodedOutputStream *output) {
 206 #define FIELD_CASE(TYPE, ACCESSOR)                             \
 207   case GPBDataType##TYPE:                                      \
 208     [output write##TYPE##NoTag:[(NSNumber *)object ACCESSOR]]; \
 209     return;
 210 #define FIELD_CASE2(TYPE)               \
 211   case GPBDataType##TYPE:               \
 212     [output write##TYPE##NoTag:object]; \
 213     return;
 214   switch (description->dataType) {
 215     FIELD_CASE(Bool, boolValue)
 216     FIELD_CASE(Float, floatValue)
 217     FIELD_CASE(Double, doubleValue)
 218     FIELD_CASE(Int32, intValue)
 219     FIELD_CASE(SFixed32, intValue)
 220     FIELD_CASE(SInt32, intValue)
 221     FIELD_CASE(Enum, intValue)
 222     FIELD_CASE(Int64, longLongValue)
 223     FIELD_CASE(SInt64, longLongValue)
 224     FIELD_CASE(SFixed64, longLongValue)
 225     FIELD_CASE(UInt32, unsignedIntValue)
 226     FIELD_CASE(Fixed32, unsignedIntValue)
 227     FIELD_CASE(UInt64, unsignedLongLongValue)
 228     FIELD_CASE(Fixed64, unsignedLongLongValue)
 229     FIELD_CASE2(Bytes)
 230     FIELD_CASE2(String)
 231     FIELD_CASE2(Message)
 232     case GPBDataTypeGroup:
 233       [output writeGroupNoTag:description->fieldNumber value:object];
 234       return;
 235   }
 236 #undef FIELD_CASE
 237 #undef FIELD_CASE2
 238 }
 239
 240 static void WriteArrayIncludingTagsToCodedOutputStream(
 241     NSArray *values, GPBExtensionDescription *description,
 242     GPBCodedOutputStream *output) {
 243   if (GPBExtensionIsPacked(description)) {
 244     [output writeTag:description->fieldNumber
 245               format:GPBWireFormatLengthDelimited];
 246     size_t dataSize = 0;
 247     size_t typeSize = DataTypeSize(description->dataType);
 248     if (typeSize != 0) {
 249       dataSize = values.count * typeSize;
 250     } else {
 251       for (id value in values) {
 252         dataSize +=
 253             ComputePBSerializedSizeNoTagOfObject(description->dataType, value);
 254       }
 255     }
 256     [output writeRawVarintSizeTAs32:dataSize];
 257     for (id value in values) {
 258       WriteObjectNoTagToCodedOutputStream(value, description, output);
 259     }
 260   } else {
 261     for (id value in values) {
 262       WriteObjectIncludingTagToCodedOutputStream(value, description, output);
 263     }
 264   }
 265 }
 266
 267 // Direct access is use for speed, to avoid even internally declaring things
 268 // read/write, etc. The warning is enabled in the project to ensure code calling
 269 // protos can turn on -Wdirect-ivar-access without issues.
 270 #pragma clang diagnostic push
 271 #pragma clang diagnostic ignored "-Wdirect-ivar-access"
 272
 273 void GPBExtensionMergeFromInputStream(GPBExtensionDescriptor *extension,
 274                                       BOOL isPackedOnStream,
 275                                       GPBCodedInputStream *input,
 276                                       GPBExtensionRegistry *extensionRegistry,
 277                                       GPBMessage *message) {
 278   GPBExtensionDescription *description = extension->description_;
 279   GPBCodedInputStreamState *state = &input->state_;
 280   if (isPackedOnStream) {
 281     NSCAssert(GPBExtensionIsRepeated(description),
 282               @"How was it packed if it isn't repeated?");
 283     int32_t length = GPBCodedInputStreamReadInt32(state);
 284     size_t limit = GPBCodedInputStreamPushLimit(state, length);
 285     while (GPBCodedInputStreamBytesUntilLimit(state) > 0) {
 286       id value = NewSingleValueFromInputStream(extension,
 287                                                input,
 288                                                extensionRegistry,
 289                                                nil);
 290       [message addExtension:extension value:value];
 291       [value release];
 292     }
 293     GPBCodedInputStreamPopLimit(state, limit);
 294   } else {
 295     id existingValue = nil;
 296     BOOL isRepeated = GPBExtensionIsRepeated(description);
 297     if (!isRepeated && GPBDataTypeIsMessage(description->dataType)) {
 298       existingValue = [message getExistingExtension:extension];
 299     }
 300     id value = NewSingleValueFromInputStream(extension,
 301                                              input,
 302                                              extensionRegistry,
 303                                              existingValue);
 304     if (isRepeated) {
 305       [message addExtension:extension value:value];
 306     } else {
 307       [message setExtension:extension value:value];
 308     }
 309     [value release];
 310   }
 311 }
 312
 313 void GPBWriteExtensionValueToOutputStream(GPBExtensionDescriptor *extension,
 314                                           id value,
 315                                           GPBCodedOutputStream *output) {
 316   GPBExtensionDescription *description = extension->description_;
 317   if (GPBExtensionIsRepeated(description)) {
 318     WriteArrayIncludingTagsToCodedOutputStream(value, description, output);
 319   } else {
 320     WriteObjectIncludingTagToCodedOutputStream(value, description, output);
 321   }
 322 }
 323
 324 size_t GPBComputeExtensionSerializedSizeIncludingTag(
 325     GPBExtensionDescriptor *extension, id value) {
 326   GPBExtensionDescription *description = extension->description_;
 327   if (GPBExtensionIsRepeated(description)) {
 328     return ComputeSerializedSizeIncludingTagOfArray(description, value);
 329   } else {
 330     return ComputeSerializedSizeIncludingTagOfObject(description, value);
 331   }
 332 }
 333
 334 // Note that this returns a retained value intentionally.
 335 static id NewSingleValueFromInputStream(GPBExtensionDescriptor *extension,
 336                                         GPBCodedInputStream *input,
 337                                         GPBExtensionRegistry *extensionRegistry,
 338                                         GPBMessage *existingValue) {
 339   GPBExtensionDescription *description = extension->description_;
 340   GPBCodedInputStreamState *state = &input->state_;
 341   switch (description->dataType) {
 342     case GPBDataTypeBool:     return [[NSNumber alloc] initWithBool:GPBCodedInputStreamReadBool(state)];
 343     case GPBDataTypeFixed32:  return [[NSNumber alloc] initWithUnsignedInt:GPBCodedInputStreamReadFixed32(state)];
 344     case GPBDataTypeSFixed32: return [[NSNumber alloc] initWithInt:GPBCodedInputStreamReadSFixed32(state)];
 345     case GPBDataTypeFloat:    return [[NSNumber alloc] initWithFloat:GPBCodedInputStreamReadFloat(state)];
 346     case GPBDataTypeFixed64:  return [[NSNumber alloc] initWithUnsignedLongLong:GPBCodedInputStreamReadFixed64(state)];
 347     case GPBDataTypeSFixed64: return [[NSNumber alloc] initWithLongLong:GPBCodedInputStreamReadSFixed64(state)];
 348     case GPBDataTypeDouble:   return [[NSNumber alloc] initWithDouble:GPBCodedInputStreamReadDouble(state)];
 349     case GPBDataTypeInt32:    return [[NSNumber alloc] initWithInt:GPBCodedInputStreamReadInt32(state)];
 350     case GPBDataTypeInt64:    return [[NSNumber alloc] initWithLongLong:GPBCodedInputStreamReadInt64(state)];
 351     case GPBDataTypeSInt32:   return [[NSNumber alloc] initWithInt:GPBCodedInputStreamReadSInt32(state)];
 352     case GPBDataTypeSInt64:   return [[NSNumber alloc] initWithLongLong:GPBCodedInputStreamReadSInt64(state)];
 353     case GPBDataTypeUInt32:   return [[NSNumber alloc] initWithUnsignedInt:GPBCodedInputStreamReadUInt32(state)];
 354     case GPBDataTypeUInt64:   return [[NSNumber alloc] initWithUnsignedLongLong:GPBCodedInputStreamReadUInt64(state)];
 355     case GPBDataTypeBytes:    return GPBCodedInputStreamReadRetainedBytes(state);
 356     case GPBDataTypeString:   return GPBCodedInputStreamReadRetainedString(state);
 357     case GPBDataTypeEnum:     return [[NSNumber alloc] initWithInt:GPBCodedInputStreamReadEnum(state)];
 358     case GPBDataTypeGroup:
 359     case GPBDataTypeMessage: {
 360       GPBMessage *message;
 361       if (existingValue) {
 362         message = [existingValue retain];
 363       } else {
 364         GPBDescriptor *decriptor = [extension.msgClass descriptor];
 365         message = [[decriptor.messageClass alloc] init];
 366       }
 367
 368       if (description->dataType == GPBDataTypeGroup) {
 369         [input readGroup:description->fieldNumber
 370                  message:message
 371             extensionRegistry:extensionRegistry];
 372       } else {
 373         // description->dataType == GPBDataTypeMessage
 374         if (GPBExtensionIsWireFormat(description)) {
 375           // For MessageSet fields the message length will have already been
 376           // read.
 377           [message mergeFromCodedInputStream:input
 378                            extensionRegistry:extensionRegistry];
 379         } else {
 380           [input readMessage:message extensionRegistry:extensionRegistry];
 381         }
 382       }
 383
 384       return message;
 385     }
 386   }
 387
 388   return nil;
 389 }
 390
 391 #pragma clang diagnostic pop