Added Android code
[wl-app.git] / iOS / Pods / Protobuf / objectivec / GPBRootObject.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 "GPBRootObject_PackagePrivate.h"
32
33 #import <objc/runtime.h>
34
35 #import <CoreFoundation/CoreFoundation.h>
36
37 #import "GPBDescriptor.h"
38 #import "GPBExtensionRegistry.h"
39 #import "GPBUtilities_PackagePrivate.h"
40
41 @interface GPBExtensionDescriptor (GPBRootObject)
42 // Get singletonName as a c string.
43 - (const char *)singletonNameC;
44 @end
45
46 // We need some object to conform to the MessageSignatureProtocol to make sure
47 // the selectors in it are recorded in our Objective C runtime information.
48 // GPBMessage is arguably the more "obvious" choice, but given that all messages
49 // inherit from GPBMessage, conflicts seem likely, so we are using GPBRootObject
50 // instead.
51 @interface GPBRootObject () <GPBMessageSignatureProtocol>
52 @end
53
54 @implementation GPBRootObject
55
56 // Taken from http://www.burtleburtle.net/bob/hash/doobs.html
57 // Public Domain
58 static uint32_t jenkins_one_at_a_time_hash(const char *key) {
59   uint32_t hash = 0;
60   for (uint32_t i = 0; key[i] != '\0'; ++i) {
61     hash += key[i];
62     hash += (hash << 10);
63     hash ^= (hash >> 6);
64   }
65   hash += (hash << 3);
66   hash ^= (hash >> 11);
67   hash += (hash << 15);
68   return hash;
69 }
70
71 // Key methods for our custom CFDictionary.
72 // Note that the dictionary lasts for the lifetime of our app, so no need
73 // to worry about deallocation. All of the items are added to it at
74 // startup, and so the keys don't need to be retained/released.
75 // Keys are NULL terminated char *.
76 static const void *GPBRootExtensionKeyRetain(CFAllocatorRef allocator,
77                                              const void *value) {
78 #pragma unused(allocator)
79   return value;
80 }
81
82 static void GPBRootExtensionKeyRelease(CFAllocatorRef allocator,
83                                        const void *value) {
84 #pragma unused(allocator)
85 #pragma unused(value)
86 }
87
88 static CFStringRef GPBRootExtensionCopyKeyDescription(const void *value) {
89   const char *key = (const char *)value;
90   return CFStringCreateWithCString(kCFAllocatorDefault, key,
91                                    kCFStringEncodingUTF8);
92 }
93
94 static Boolean GPBRootExtensionKeyEqual(const void *value1,
95                                         const void *value2) {
96   const char *key1 = (const char *)value1;
97   const char *key2 = (const char *)value2;
98   return strcmp(key1, key2) == 0;
99 }
100
101 static CFHashCode GPBRootExtensionKeyHash(const void *value) {
102   const char *key = (const char *)value;
103   return jenkins_one_at_a_time_hash(key);
104 }
105
106 // NOTE: OSSpinLock may seem like a good fit here but Apple engineers have
107 // pointed out that they are vulnerable to live locking on iOS in cases of
108 // priority inversion:
109 //   http://mjtsai.com/blog/2015/12/16/osspinlock-is-unsafe/
110 //   https://lists.swift.org/pipermail/swift-dev/Week-of-Mon-20151214/000372.html
111 static dispatch_semaphore_t gExtensionSingletonDictionarySemaphore;
112 static CFMutableDictionaryRef gExtensionSingletonDictionary = NULL;
113 static GPBExtensionRegistry *gDefaultExtensionRegistry = NULL;
114
115 + (void)initialize {
116   // Ensure the global is started up.
117   if (!gExtensionSingletonDictionary) {
118     gExtensionSingletonDictionarySemaphore = dispatch_semaphore_create(1);
119     CFDictionaryKeyCallBacks keyCallBacks = {
120       // See description above for reason for using custom dictionary.
121       0,
122       GPBRootExtensionKeyRetain,
123       GPBRootExtensionKeyRelease,
124       GPBRootExtensionCopyKeyDescription,
125       GPBRootExtensionKeyEqual,
126       GPBRootExtensionKeyHash,
127     };
128     gExtensionSingletonDictionary =
129         CFDictionaryCreateMutable(kCFAllocatorDefault, 0, &keyCallBacks,
130                                   &kCFTypeDictionaryValueCallBacks);
131     gDefaultExtensionRegistry = [[GPBExtensionRegistry alloc] init];
132   }
133
134   if ([self superclass] == [GPBRootObject class]) {
135     // This is here to start up all the per file "Root" subclasses.
136     // This must be done in initialize to enforce thread safety of start up of
137     // the protocol buffer library.
138     [self extensionRegistry];
139   }
140 }
141
142 + (GPBExtensionRegistry *)extensionRegistry {
143   // Is overridden in all the subclasses that provide extensions to provide the
144   // per class one.
145   return gDefaultExtensionRegistry;
146 }
147
148 + (void)globallyRegisterExtension:(GPBExtensionDescriptor *)field {
149   const char *key = [field singletonNameC];
150   dispatch_semaphore_wait(gExtensionSingletonDictionarySemaphore,
151                           DISPATCH_TIME_FOREVER);
152   CFDictionarySetValue(gExtensionSingletonDictionary, key, field);
153   dispatch_semaphore_signal(gExtensionSingletonDictionarySemaphore);
154 }
155
156 static id ExtensionForName(id self, SEL _cmd) {
157   // Really fast way of doing "classname_selName".
158   // This came up as a hotspot (creation of NSString *) when accessing a
159   // lot of extensions.
160   const char *selName = sel_getName(_cmd);
161   if (selName[0] == '_') {
162     return nil;  // Apple internal selector.
163   }
164   size_t selNameLen = 0;
165   while (1) {
166     char c = selName[selNameLen];
167     if (c == '\0') {  // String end.
168       break;
169     }
170     if (c == ':') {
171       return nil;  // Selector took an arg, not one of the runtime methods.
172     }
173     ++selNameLen;
174   }
175
176   const char *className = class_getName(self);
177   size_t classNameLen = strlen(className);
178   char key[classNameLen + selNameLen + 2];
179   memcpy(key, className, classNameLen);
180   key[classNameLen] = '_';
181   memcpy(&key[classNameLen + 1], selName, selNameLen);
182   key[classNameLen + 1 + selNameLen] = '\0';
183
184   // NOTE: Even though this method is called from another C function,
185   // gExtensionSingletonDictionarySemaphore and gExtensionSingletonDictionary
186   // will always be initialized. This is because this call flow is just to
187   // lookup the Extension, meaning the code is calling an Extension class
188   // message on a Message or Root class. This guarantees that the class was
189   // initialized and Message classes ensure their Root was also initialized.
190   NSAssert(gExtensionSingletonDictionary, @"Startup order broken!");
191
192   dispatch_semaphore_wait(gExtensionSingletonDictionarySemaphore,
193                           DISPATCH_TIME_FOREVER);
194   id extension = (id)CFDictionaryGetValue(gExtensionSingletonDictionary, key);
195   // We can't remove the key from the dictionary here (as an optimization),
196   // two threads could have gone into +resolveClassMethod: for the same method,
197   // and ended up here; there's no way to ensure both return YES without letting
198   // both try to wire in the method.
199   dispatch_semaphore_signal(gExtensionSingletonDictionarySemaphore);
200   return extension;
201 }
202
203 BOOL GPBResolveExtensionClassMethod(Class self, SEL sel) {
204   // Another option would be to register the extensions with the class at
205   // globallyRegisterExtension:
206   // Timing the two solutions, this solution turned out to be much faster
207   // and reduced startup time, and runtime memory.
208   // The advantage to globallyRegisterExtension is that it would reduce the
209   // size of the protos somewhat because the singletonNameC wouldn't need
210   // to include the class name. For a class with a lot of extensions it
211   // can add up. You could also significantly reduce the code complexity of this
212   // file.
213   id extension = ExtensionForName(self, sel);
214   if (extension != nil) {
215     const char *encoding =
216         GPBMessageEncodingForSelector(@selector(getClassValue), NO);
217     Class metaClass = objc_getMetaClass(class_getName(self));
218     IMP imp = imp_implementationWithBlock(^(id obj) {
219 #pragma unused(obj)
220       return extension;
221     });
222     BOOL methodAdded = class_addMethod(metaClass, sel, imp, encoding);
223     // class_addMethod() is documented as also failing if the method was already
224     // added; so we check if the method is already there and return success so
225     // the method dispatch will still happen.  Why would it already be added?
226     // Two threads could cause the same method to be bound at the same time,
227     // but only one will actually bind it; the other still needs to return true
228     // so things will dispatch.
229     if (!methodAdded) {
230       methodAdded = GPBClassHasSel(metaClass, sel);
231     }
232     return methodAdded;
233   }
234   return NO;
235 }
236
237
238 + (BOOL)resolveClassMethod:(SEL)sel {
239   if (GPBResolveExtensionClassMethod(self, sel)) {
240     return YES;
241   }
242   return [super resolveClassMethod:sel];
243 }
244
245 @end