| // Protocol Buffers - Google's data interchange format |
| // Copyright 2008 Google Inc. All rights reserved. |
| // |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file or at |
| // https://developers.google.com/open-source/licenses/bsd |
| |
| // This header is private to the ProtobolBuffers library and must NOT be |
| // included by any sources outside this library. The contents of this file are |
| // subject to change at any time without notice. |
| |
| #import "GPBDescriptor.h" |
| #import "GPBWireFormat.h" |
| |
| // Describes attributes of the field. |
| typedef NS_OPTIONS(uint16_t, GPBFieldFlags) { |
| GPBFieldNone = 0, |
| // These map to standard protobuf concepts. |
| GPBFieldRequired = 1 << 0, |
| GPBFieldRepeated = 1 << 1, |
| GPBFieldPacked = 1 << 2, |
| GPBFieldOptional = 1 << 3, |
| GPBFieldHasDefaultValue = 1 << 4, |
| |
| // Indicate that the field should "clear" when set to zero value. This is the |
| // proto3 non optional behavior for singular data (ints, data, string, enum) |
| // fields. |
| GPBFieldClearHasIvarOnZero = 1 << 5, |
| // Indicates the field needs custom handling for the TextFormat name, if not |
| // set, the name can be derived from the ObjC name. |
| GPBFieldTextFormatNameCustom = 1 << 6, |
| // This flag has never had any meaning, it was set on all enum fields. |
| GPBFieldHasEnumDescriptor = 1 << 7, |
| |
| // These are not standard protobuf concepts, they are specific to the |
| // Objective C runtime. |
| |
| // These bits are used to mark the field as a map and what the key |
| // type is. |
| GPBFieldMapKeyMask = 0xF << 8, |
| GPBFieldMapKeyInt32 = 1 << 8, |
| GPBFieldMapKeyInt64 = 2 << 8, |
| GPBFieldMapKeyUInt32 = 3 << 8, |
| GPBFieldMapKeyUInt64 = 4 << 8, |
| GPBFieldMapKeySInt32 = 5 << 8, |
| GPBFieldMapKeySInt64 = 6 << 8, |
| GPBFieldMapKeyFixed32 = 7 << 8, |
| GPBFieldMapKeyFixed64 = 8 << 8, |
| GPBFieldMapKeySFixed32 = 9 << 8, |
| GPBFieldMapKeySFixed64 = 10 << 8, |
| GPBFieldMapKeyBool = 11 << 8, |
| GPBFieldMapKeyString = 12 << 8, |
| |
| // If the enum for this field is "closed", meaning that it: |
| // - Has a fixed set of named values. |
| // - Encountering values not in this set causes them to be treated as unknown |
| // fields. |
| // - The first value (i.e., the default) may be nonzero. |
| // NOTE: This could be tracked just on the GPBEnumDescriptor, but to support |
| // previously generated code, there would be not data to get the behavior |
| // correct, so instead it is tracked on the field. If old source compatibility |
| // is removed, this could be removed and the GPBEnumDescription fetched from |
| // the GPBFieldDescriptor instead. |
| GPBFieldClosedEnum = 1 << 12, |
| }; |
| |
| // NOTE: The structures defined here have their members ordered to minimize |
| // their size. This directly impacts the size of apps since these exist per |
| // field/extension. |
| |
| typedef struct GPBFileDescription { |
| // The proto package for the file. |
| const char *package; |
| // The objc_class_prefix option if present. |
| const char *prefix; |
| // The file's proto syntax. |
| GPBFileSyntax syntax; |
| } GPBFileDescription; |
| |
| // Describes a single field in a protobuf as it is represented as an ivar. |
| typedef struct GPBMessageFieldDescription { |
| // Name of ivar. |
| // Note that we looked into using a SEL here instead (which really is just a C string) |
| // but there is not a way to initialize an SEL with a constant (@selector is not constant) so the |
| // additional code generated to initialize the value is actually bigger in size than just using a |
| // C identifier for large apps. |
| const char *name; |
| union { |
| // className is deprecated and will be removed in favor of clazz. |
| // kept around right now for backwards compatibility. |
| // clazz is used iff GPBDescriptorInitializationFlag_UsesClassRefs is set. |
| char *className; // Name of the class of the message. |
| Class clazz; // Class of the message. |
| // For enums only. |
| GPBEnumDescriptorFunc enumDescFunc; |
| } dataTypeSpecific; |
| // The field number for the ivar. |
| uint32_t number; |
| // The index (in bits) into _has_storage_. |
| // >= 0: the bit to use for a value being set. |
| // = GPBNoHasBit(INT32_MAX): no storage used. |
| // < 0: in a oneOf, use a full int32 to record the field active. |
| int32_t hasIndex; |
| // Offset of the variable into it's structure struct. |
| uint32_t offset; |
| // Field flags. Use accessor functions below. |
| GPBFieldFlags flags; |
| // Data type of the ivar. |
| GPBDataType dataType; |
| } GPBMessageFieldDescription; |
| |
| // If a message uses fields where they provide default values that are non zero, then this |
| // struct is used to provide the values along with the field info. |
| typedef struct GPBMessageFieldDescriptionWithDefault { |
| // Default value for the ivar. |
| GPBGenericValue defaultValue; |
| |
| GPBMessageFieldDescription core; |
| } GPBMessageFieldDescriptionWithDefault; |
| |
| // Describes attributes of the extension. |
| typedef NS_OPTIONS(uint8_t, GPBExtensionOptions) { |
| GPBExtensionNone = 0, |
| // These map to standard protobuf concepts. |
| GPBExtensionRepeated = 1 << 0, |
| GPBExtensionPacked = 1 << 1, |
| GPBExtensionSetWireFormat = 1 << 2, |
| }; |
| |
| // An extension |
| typedef struct GPBExtensionDescription { |
| GPBGenericValue defaultValue; |
| const char *singletonName; |
| // Before 3.12, `extendedClass` was just a `const char *`. Thanks to nested |
| // initialization |
| // (https://en.cppreference.com/w/c/language/struct_initialization#Nested_initialization) old |
| // generated code with `.extendedClass = GPBStringifySymbol(Something)` still works; and the |
| // current generator can use `extendedClass.clazz`, to pass a Class reference. |
| union { |
| const char *name; |
| Class clazz; |
| } extendedClass; |
| // Before 3.12, this was `const char *messageOrGroupClassName`. In the |
| // initial 3.12 release, we moved the `union messageOrGroupClass`, and failed |
| // to realize that would break existing source code for extensions. So to |
| // keep existing source code working, we added an unnamed union (C11) to |
| // provide both the old field name and the new union. This keeps both older |
| // and newer code working. |
| // Background: https://github.com/protocolbuffers/protobuf/issues/7555 |
| union { |
| const char *messageOrGroupClassName; |
| union { |
| const char *name; |
| Class clazz; |
| } messageOrGroupClass; |
| }; |
| GPBEnumDescriptorFunc enumDescriptorFunc; |
| int32_t fieldNumber; |
| GPBDataType dataType; |
| GPBExtensionOptions options; |
| } GPBExtensionDescription; |
| |
| typedef NS_OPTIONS(uint32_t, GPBDescriptorInitializationFlags) { |
| GPBDescriptorInitializationFlag_None = 0, |
| GPBDescriptorInitializationFlag_FieldsWithDefault = 1 << 0, |
| GPBDescriptorInitializationFlag_WireFormat = 1 << 1, |
| |
| // This is used as a stopgap as we move from using class names to class |
| // references. The runtime needs to support both until we allow a |
| // breaking change in the runtime. |
| GPBDescriptorInitializationFlag_UsesClassRefs = 1 << 2, |
| |
| // This flag is used to indicate that the generated sources already contain |
| // the `GPBFieldClearHasIvarOnZero` flag and it doesn't have to be computed |
| // at startup. This allows older generated code to still work with the |
| // current runtime library. |
| GPBDescriptorInitializationFlag_Proto3OptionalKnown = 1 << 3, |
| |
| // This flag is used to indicate that the generated sources already contain |
| // the `GPBFieldCloseEnum` flag and it doesn't have to be computed at startup. |
| // This allows the older generated code to still work with the current runtime |
| // library. |
| GPBDescriptorInitializationFlag_ClosedEnumSupportKnown = 1 << 4, |
| }; |
| |
| @interface GPBDescriptor () { |
| @package |
| NSArray *fields_; |
| NSArray *oneofs_; |
| uint32_t storageSize_; |
| } |
| |
| // fieldDescriptions and fileDescription have to be long lived, they are held as raw pointers. |
| + (instancetype)allocDescriptorForClass:(Class)messageClass |
| messageName:(NSString *)messageName |
| fileDescription:(GPBFileDescription *)fileDescription |
| fields:(void *)fieldDescriptions |
| fieldCount:(uint32_t)fieldCount |
| storageSize:(uint32_t)storageSize |
| flags:(GPBDescriptorInitializationFlags)flags; |
| |
| // Called right after init to provide extra information to avoid init having |
| // an explosion of args. These pointers are recorded, so they are expected |
| // to live for the lifetime of the app. |
| - (void)setupOneofs:(const char **)oneofNames |
| count:(uint32_t)count |
| firstHasIndex:(int32_t)firstHasIndex; |
| - (void)setupExtraTextInfo:(const char *)extraTextFormatInfo; |
| - (void)setupExtensionRanges:(const GPBExtensionRange *)ranges count:(int32_t)count; |
| - (void)setupContainingMessageClass:(Class)msgClass; |
| |
| // Deprecated, these remain to support older versions of source generation. |
| + (instancetype)allocDescriptorForClass:(Class)messageClass |
| file:(GPBFileDescriptor *)file |
| fields:(void *)fieldDescriptions |
| fieldCount:(uint32_t)fieldCount |
| storageSize:(uint32_t)storageSize |
| flags:(GPBDescriptorInitializationFlags)flags; |
| + (instancetype)allocDescriptorForClass:(Class)messageClass |
| rootClass:(Class)rootClass |
| file:(GPBFileDescriptor *)file |
| fields:(void *)fieldDescriptions |
| fieldCount:(uint32_t)fieldCount |
| storageSize:(uint32_t)storageSize |
| flags:(GPBDescriptorInitializationFlags)flags; |
| - (void)setupContainingMessageClassName:(const char *)msgClassName; |
| - (void)setupMessageClassNameSuffix:(NSString *)suffix; |
| |
| @end |
| |
| @interface GPBFileDescriptor () |
| - (instancetype)initWithPackage:(NSString *)package |
| objcPrefix:(NSString *)objcPrefix |
| syntax:(GPBFileSyntax)syntax; |
| - (instancetype)initWithPackage:(NSString *)package syntax:(GPBFileSyntax)syntax; |
| @end |
| |
| @interface GPBOneofDescriptor () { |
| @package |
| const char *name_; |
| NSArray *fields_; |
| } |
| // name must be long lived. |
| - (instancetype)initWithName:(const char *)name fields:(NSArray *)fields; |
| @end |
| |
| @interface GPBFieldDescriptor () { |
| @package |
| GPBMessageFieldDescription *description_; |
| GPB_UNSAFE_UNRETAINED GPBOneofDescriptor *containingOneof_; |
| } |
| @end |
| |
| typedef NS_OPTIONS(uint32_t, GPBEnumDescriptorInitializationFlags) { |
| GPBEnumDescriptorInitializationFlag_None = 0, |
| |
| // Available: 1 << 0 |
| |
| // Marks this enum as a closed enum. |
| GPBEnumDescriptorInitializationFlag_IsClosed = 1 << 1, |
| }; |
| |
| @interface GPBEnumDescriptor () |
| // valueNames, values and extraTextFormatInfo have to be long lived, they are |
| // held as raw pointers. |
| + (instancetype)allocDescriptorForName:(NSString *)name |
| valueNames:(const char *)valueNames |
| values:(const int32_t *)values |
| count:(uint32_t)valueCount |
| enumVerifier:(GPBEnumValidationFunc)enumVerifier |
| flags:(GPBEnumDescriptorInitializationFlags)flags; |
| + (instancetype)allocDescriptorForName:(NSString *)name |
| valueNames:(const char *)valueNames |
| values:(const int32_t *)values |
| count:(uint32_t)valueCount |
| enumVerifier:(GPBEnumValidationFunc)enumVerifier |
| flags:(GPBEnumDescriptorInitializationFlags)flags |
| extraTextFormatInfo:(const char *)extraTextFormatInfo; |
| |
| // Deprecated, these remain to support older versions of source generation. |
| + (instancetype)allocDescriptorForName:(NSString *)name |
| valueNames:(const char *)valueNames |
| values:(const int32_t *)values |
| count:(uint32_t)valueCount |
| enumVerifier:(GPBEnumValidationFunc)enumVerifier; |
| + (instancetype)allocDescriptorForName:(NSString *)name |
| valueNames:(const char *)valueNames |
| values:(const int32_t *)values |
| count:(uint32_t)valueCount |
| enumVerifier:(GPBEnumValidationFunc)enumVerifier |
| extraTextFormatInfo:(const char *)extraTextFormatInfo; |
| @end |
| |
| @interface GPBExtensionDescriptor () { |
| @package |
| GPBExtensionDescription *description_; |
| } |
| @property(nonatomic, readonly) GPBWireFormat wireType; |
| |
| // For repeated extensions, alternateWireType is the wireType with the opposite |
| // value for the packable property. i.e. - if the extension was marked packed |
| // it would be the wire type for unpacked; if the extension was marked unpacked, |
| // it would be the wire type for packed. |
| @property(nonatomic, readonly) GPBWireFormat alternateWireType; |
| |
| // description has to be long lived, it is held as a raw pointer. |
| - (instancetype)initWithExtensionDescription:(GPBExtensionDescription *)desc |
| usesClassRefs:(BOOL)usesClassRefs; |
| // Deprecated. Calls above with `usesClassRefs = NO` |
| - (instancetype)initWithExtensionDescription:(GPBExtensionDescription *)desc; |
| |
| - (NSComparisonResult)compareByFieldNumber:(GPBExtensionDescriptor *)other; |
| @end |
| |
| CF_EXTERN_C_BEGIN |
| |
| // Direct access is use for speed, to avoid even internally declaring things |
| // read/write, etc. The warning is enabled in the project to ensure code calling |
| // protos can turn on -Wdirect-ivar-access without issues. |
| #pragma clang diagnostic push |
| #pragma clang diagnostic ignored "-Wdirect-ivar-access" |
| |
| GPB_INLINE BOOL GPBFieldIsMapOrArray(GPBFieldDescriptor *field) { |
| return (field->description_->flags & (GPBFieldRepeated | GPBFieldMapKeyMask)) != 0; |
| } |
| |
| GPB_INLINE GPBDataType GPBGetFieldDataType(GPBFieldDescriptor *field) { |
| return field->description_->dataType; |
| } |
| |
| GPB_INLINE int32_t GPBFieldHasIndex(GPBFieldDescriptor *field) { |
| return field->description_->hasIndex; |
| } |
| |
| GPB_INLINE uint32_t GPBFieldNumber(GPBFieldDescriptor *field) { |
| return field->description_->number; |
| } |
| |
| GPB_INLINE BOOL GPBFieldIsClosedEnum(GPBFieldDescriptor *field) { |
| return (field->description_->flags & GPBFieldClosedEnum) != 0; |
| } |
| |
| #pragma clang diagnostic pop |
| |
| uint32_t GPBFieldTag(GPBFieldDescriptor *self); |
| |
| // For repeated fields, alternateWireType is the wireType with the opposite |
| // value for the packable property. i.e. - if the field was marked packed it |
| // would be the wire type for unpacked; if the field was marked unpacked, it |
| // would be the wire type for packed. |
| uint32_t GPBFieldAlternateTag(GPBFieldDescriptor *self); |
| |
| GPB_INLINE BOOL GPBExtensionIsRepeated(GPBExtensionDescription *description) { |
| return (description->options & GPBExtensionRepeated) != 0; |
| } |
| |
| GPB_INLINE BOOL GPBExtensionIsPacked(GPBExtensionDescription *description) { |
| return (description->options & GPBExtensionPacked) != 0; |
| } |
| |
| GPB_INLINE BOOL GPBExtensionIsWireFormat(GPBExtensionDescription *description) { |
| return (description->options & GPBExtensionSetWireFormat) != 0; |
| } |
| |
| // Helper for compile time assets. |
| #ifndef GPBInternalCompileAssert |
| #define GPBInternalCompileAssert(test, msg) _Static_assert((test), #msg) |
| #endif // GPBInternalCompileAssert |
| |
| // Sanity check that there isn't padding between the field description |
| // structures with and without a default. |
| GPBInternalCompileAssert(sizeof(GPBMessageFieldDescriptionWithDefault) == |
| (sizeof(GPBGenericValue) + sizeof(GPBMessageFieldDescription)), |
| DescriptionsWithDefault_different_size_than_expected); |
| |
| CF_EXTERN_C_END |