MasterPassword/External/google-plus-ios-sdk/OpenSource/GTL/GTLRuntimeCommon.m

/* Copyright (c) 2011 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

//
//  GTLRuntimeCommon.m
//

#include <objc/runtime.h>

#import "GTLRuntimeCommon.h"

#import "GTLDateTime.h"
#import "GTLObject.h"
#import "GTLUtilities.h"

static NSString *const kReturnClassKey = @"returnClass";
static NSString *const kContainedClassKey = @"containedClass";
static NSString *const kJSONKey = @"jsonKey";

// Note: NSObject's class is used as a marker for the expected/default class
// when Discovery says it can be any type of object.

@implementation GTLRuntimeCommon

// Helper to generically convert JSON to an api object type.
+ (id)objectFromJSON:(id)json
        defaultClass:(Class)defaultClass
          surrogates:(NSDictionary *)surrogates
         isCacheable:(BOOL*)isCacheable {
  id result = nil;
  BOOL canBeCached = YES;

  // TODO(TVL): use defaultClass to validate things like expectedClass is
  // done in jsonFromAPIObject:expectedClass:isCacheable:?

  if ([json isKindOfClass:[NSDictionary class]]) {
    // If no default, or the default was any object, then default to base
    // object here (and hope there is a kind to get the right thing).
    if ((defaultClass == Nil) || [defaultClass isEqual:[NSObject class]]) {
      defaultClass = [GTLObject class];
    }
    result = [GTLObject objectForJSON:json
                         defaultClass:defaultClass
                           surrogates:surrogates
                        batchClassMap:nil];
  } else if ([json isKindOfClass:[NSArray class]]) {
    NSArray *jsonArray = json;
    // make an object for each JSON dictionary in the array
    NSMutableArray *resultArray = [NSMutableArray arrayWithCapacity:[jsonArray count]];
    for (id jsonItem in jsonArray) {
      id item = [self objectFromJSON:jsonItem
                        defaultClass:defaultClass
                          surrogates:surrogates
                         isCacheable:NULL];
      [resultArray addObject:item];
    }
    result = resultArray;
  } else if ([json isKindOfClass:[NSString class]]) {
    // DateTimes live in JSON as strings, so convert
    if ([defaultClass isEqual:[GTLDateTime class]]) {
      result = [GTLDateTime dateTimeWithRFC3339String:json];
    } else {
      result = json;
      canBeCached = NO;
    }
  } else if ([json isKindOfClass:[NSNumber class]] ||
             [json isKindOfClass:[NSNull class]]) {
    result = json;
    canBeCached = NO;
  } else {
    GTL_DEBUG_LOG(@"GTLRuntimeCommon: unsupported class '%s' in objectFromJSON",
                  class_getName([json class]));
  }

  if (isCacheable) {
    *isCacheable = canBeCached;
  }
  return result;
}

// Helper to generically convert an api object type to JSON.
// |expectedClass| is the type that was expected for |obj|.
+ (id)jsonFromAPIObject:(id)obj
          expectedClass:(Class)expectedClass
            isCacheable:(BOOL*)isCacheable {
  id result = nil;
  BOOL canBeCached = YES;
  BOOL checkExpected = (expectedClass != Nil);

  if ([obj isKindOfClass:[NSString class]]) {
    result = [[obj copy] autorelease];
    canBeCached = NO;
  } else if ([obj isKindOfClass:[NSNumber class]] ||
             [obj isKindOfClass:[NSNull class]]) {
      result = obj;
      canBeCached = NO;
  } else if ([obj isKindOfClass:[GTLObject class]]) {
    result = [obj JSON];
    if (result == nil) {
      // adding an empty object; it should have a JSON dictionary so it can
      // hold future assignments
      [obj setJSON:[NSMutableDictionary dictionary]];
      result = [obj JSON];
    }
  } else if ([obj isKindOfClass:[NSArray class]]) {
    checkExpected = NO;
    NSArray *array = obj;
    // get the JSON for each thing in the array
    NSMutableArray *resultArray = [NSMutableArray arrayWithCapacity:[array count]];
    for (id item in array) {
      id itemJSON = [self jsonFromAPIObject:item
                              expectedClass:expectedClass
                                isCacheable:NULL];
      [resultArray addObject:itemJSON];
    }
    result = resultArray;
  } else if ([obj isKindOfClass:[GTLDateTime class]]) {
    // DateTimes live in JSON as strings, so convert.
    GTLDateTime *dateTime = obj;
    result = [dateTime stringValue];
  } else {
    checkExpected = NO;
    GTL_DEBUG_LOG(@"GTLRuntimeCommon: unsupported class '%s' in jsonFromAPIObject",
                  class_getName([obj class]));
  }

  if (checkExpected) {
    // If the default was any object, then clear it to skip validation checks.
    if ([expectedClass isEqual:[NSObject class]] ||
        [obj isKindOfClass:[NSNull class]]) {
      expectedClass = nil;
    }
    if (expectedClass && ![obj isKindOfClass:expectedClass]) {
      GTL_DEBUG_LOG(@"GTLRuntimeCommon: jsonFromAPIObject expected class '%s' instead got '%s'",
                    class_getName(expectedClass), class_getName([obj class]));
    }
  }

  if (isCacheable) {
    *isCacheable = canBeCached;
  }
  return result;
}

#pragma mark JSON/Object Utilities

static NSMutableDictionary *gDispatchCache = nil;

static CFStringRef SelectorKeyCopyDescriptionCallBack(const void *key) {
  // Make a CFString from the key
  NSString *name = NSStringFromSelector((SEL) key);
  CFStringRef str = CFStringCreateCopy(kCFAllocatorDefault, (CFStringRef) name);
  return str;
}

// Save the dispatch details for the specified class and selector
+ (void)setStoredDispatchForClass:(Class<GTLRuntimeCommon>)dispatchClass
                         selector:(SEL)sel
                      returnClass:(Class)returnClass
                   containedClass:(Class)containedClass
                          jsonKey:(NSString *)jsonKey {
  // cache structure:
  //   class ->
  //     selector ->
  //       returnClass
  //       containedClass
  //       jsonKey
  @synchronized([GTLRuntimeCommon class]) {
    if (gDispatchCache == nil) {
      gDispatchCache = [GTLUtilities newStaticDictionary];
    }

    CFMutableDictionaryRef classDict =
      (CFMutableDictionaryRef) [gDispatchCache objectForKey:dispatchClass];
    if (classDict == nil) {
      // We create a CFDictionary since the keys are raw selectors rather than
      // NSStrings
      const CFDictionaryKeyCallBacks keyCallBacks = {
        .version = 0,
        .retain = NULL,
        .release = NULL,
        .copyDescription = SelectorKeyCopyDescriptionCallBack,
        .equal = NULL,  // defaults to pointer comparison
        .hash = NULL    // defaults to the pointer value
      };
      const CFIndex capacity = 0; // no limit
      classDict = CFDictionaryCreateMutable(kCFAllocatorDefault, capacity,
                                            &keyCallBacks,
                                            &kCFTypeDictionaryValueCallBacks);
      [gDispatchCache setObject:(id)classDict
                         forKey:(id<NSCopying>)dispatchClass];
      CFRelease(classDict);
    }

    NSDictionary *selDict = (NSDictionary *)CFDictionaryGetValue(classDict, sel);
    if (selDict == nil) {
      selDict = [NSDictionary dictionaryWithObjectsAndKeys:
                 jsonKey, kJSONKey,
                 returnClass, kReturnClassKey, // can be nil (primitive types)
                 containedClass, kContainedClassKey, // may be nil
                 nil];
      CFDictionarySetValue(classDict, sel, selDict);
    } else {
      // we already have a dictionary for this selector on this class, which is
      // surprising
      GTL_DEBUG_LOG(@"Storing duplicate dispatch for %@ selector %@",
            dispatchClass, NSStringFromSelector(sel));
    }
  }
}

+ (BOOL)getStoredDispatchForClass:(Class<GTLRuntimeCommon>)dispatchClass
                         selector:(SEL)sel
                      returnClass:(Class *)outReturnClass
                   containedClass:(Class *)outContainedClass
                          jsonKey:(NSString **)outJsonKey {
  @synchronized([GTLRuntimeCommon class]) {
    // walk from this class up the hierarchy to the ancestor class
    Class<GTLRuntimeCommon> topClass = class_getSuperclass([dispatchClass ancestorClass]);
    for (Class currClass = dispatchClass;
         currClass != topClass;
         currClass = class_getSuperclass(currClass)) {

      CFMutableDictionaryRef classDict =
        (CFMutableDictionaryRef) [gDispatchCache objectForKey:currClass];
      if (classDict) {
        NSMutableDictionary *selDict =
          (NSMutableDictionary *) CFDictionaryGetValue(classDict, sel);
        if (selDict) {
          if (outReturnClass) {
            *outReturnClass = [selDict objectForKey:kReturnClassKey];
          }
          if (outContainedClass) {
            *outContainedClass = [selDict objectForKey:kContainedClassKey];
          }
          if (outJsonKey) {
            *outJsonKey = [selDict objectForKey:kJSONKey];
          }
          return YES;
        }
      }
    }
  }
  GTL_DEBUG_LOG(@"Failed to find stored dispatch info for %@ %s",
        dispatchClass, sel_getName(sel));
  return NO;
}

#pragma mark IMPs - getters and setters for specific object types

#if !__LP64__

// NSInteger on 32bit
static NSInteger DynamicInteger32Getter(id self, SEL sel) {
  // get an NSInteger (NSNumber) from the JSON dictionary
  NSString *jsonKey = nil;
  Class<GTLRuntimeCommon> selfClass = [self class];
  if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass
                                         selector:sel
                                      returnClass:NULL
                                   containedClass:NULL
                                          jsonKey:&jsonKey]) {
    NSNumber *num = [self JSONValueForKey:jsonKey];
    num = GTL_EnsureNSNumber(num);
    NSInteger result = [num integerValue];
    return result;
  }
  return 0;
}

static void DynamicInteger32Setter(id self, SEL sel, NSInteger val) {
  // save an NSInteger (NSNumber) into the JSON dictionary
  NSString *jsonKey = nil;
  Class<GTLRuntimeCommon> selfClass = [self class];
  if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass
                                         selector:sel
                                      returnClass:NULL
                                   containedClass:NULL
                                          jsonKey:&jsonKey]) {
    NSNumber *num = [NSNumber numberWithInteger:val];
    [self setJSONValue:num forKey:jsonKey];
  }
}

// NSUInteger on 32bit
static NSUInteger DynamicUInteger32Getter(id self, SEL sel) {
  // get an NSUInteger (NSNumber) from the JSON dictionary
  NSString *jsonKey = nil;
  Class<GTLRuntimeCommon> selfClass = [self class];
  if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass
                                         selector:sel
                                      returnClass:NULL
                                   containedClass:NULL
                                          jsonKey:&jsonKey]) {
    NSNumber *num = [self JSONValueForKey:jsonKey];
    num = GTL_EnsureNSNumber(num);
    NSUInteger result = [num unsignedIntegerValue];
    return result;
  }
  return 0;
}

static void DynamicUInteger32Setter(id self, SEL sel, NSUInteger val) {
  // save an NSUInteger (NSNumber) into the JSON dictionary
  NSString *jsonKey = nil;
  Class<GTLRuntimeCommon> selfClass = [self class];
  if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass
                                         selector:sel
                                      returnClass:NULL
                                   containedClass:NULL
                                          jsonKey:&jsonKey]) {
    NSNumber *num = [NSNumber numberWithUnsignedInteger:val];
    [self setJSONValue:num forKey:jsonKey];
  }
}

#endif  // !__LP64__

// NSInteger on 64bit, long long on 32bit and 64bit
static long long DynamicLongLongGetter(id self, SEL sel) {
  // get a long long (NSNumber) from the JSON dictionary
  NSString *jsonKey = nil;
  Class<GTLRuntimeCommon> selfClass = [self class];
  if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass
                                         selector:sel
                                      returnClass:NULL
                                   containedClass:NULL
                                          jsonKey:&jsonKey]) {
    NSNumber *num = [self JSONValueForKey:jsonKey];
    num = GTL_EnsureNSNumber(num);
    long long result = [num longLongValue];
    return result;
  }
  return 0;
}

static void DynamicLongLongSetter(id self, SEL sel, long long val) {
  // save a long long (NSNumber) into the JSON dictionary
  NSString *jsonKey = nil;
  Class<GTLRuntimeCommon> selfClass = [self class];
  if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass
                                         selector:sel
                                      returnClass:NULL
                                   containedClass:NULL
                                          jsonKey:&jsonKey]) {
    NSNumber *num = [NSNumber numberWithLongLong:val];
    [self setJSONValue:num forKey:jsonKey];
  }
}

// NSUInteger on 64bit, unsiged long long on 32bit and 64bit
static unsigned long long DynamicULongLongGetter(id self, SEL sel) {
  // get an unsigned long long (NSNumber) from the JSON dictionary
  NSString *jsonKey = nil;
  Class<GTLRuntimeCommon> selfClass = [self class];
  if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass
                                         selector:sel
                                      returnClass:NULL
                                   containedClass:NULL
                                          jsonKey:&jsonKey]) {
    NSNumber *num = [self JSONValueForKey:jsonKey];
    num = GTL_EnsureNSNumber(num);
    unsigned long long result = [num unsignedLongLongValue];
    return result;
  }
  return 0;
}

static void DynamicULongLongSetter(id self, SEL sel, unsigned long long val) {
  // save an unsigned long long (NSNumber) into the JSON dictionary
  NSString *jsonKey = nil;
  Class<GTLRuntimeCommon> selfClass = [self class];
  if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass
                                         selector:sel
                                      returnClass:NULL
                                   containedClass:NULL
                                          jsonKey:&jsonKey]) {
    NSNumber *num = [NSNumber numberWithUnsignedLongLong:val];
    [self setJSONValue:num forKey:jsonKey];
  }
}

// float
static float DynamicFloatGetter(id self, SEL sel) {
  // get a float (NSNumber) from the JSON dictionary
  NSString *jsonKey = nil;
  Class<GTLRuntimeCommon> selfClass = [self class];
  if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass
                                         selector:sel
                                      returnClass:NULL
                                   containedClass:NULL
                                          jsonKey:&jsonKey]) {
    NSNumber *num = [self JSONValueForKey:jsonKey];
    num = GTL_EnsureNSNumber(num);
    float result = [num floatValue];
    return result;
  }
  return 0.0f;
}

static void DynamicFloatSetter(id self, SEL sel, float val) {
  // save a float (NSNumber) into the JSON dictionary
  NSString *jsonKey = nil;
  Class<GTLRuntimeCommon> selfClass = [self class];
  if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass
                                         selector:sel
                                      returnClass:NULL
                                   containedClass:NULL
                                          jsonKey:&jsonKey]) {
    NSNumber *num = [NSNumber numberWithFloat:val];
    [self setJSONValue:num forKey:jsonKey];
  }
}

// double
static double DynamicDoubleGetter(id self, SEL sel) {
  // get a double (NSNumber) from the JSON dictionary
  NSString *jsonKey = nil;
  Class<GTLRuntimeCommon> selfClass = [self class];
  if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass
                                         selector:sel
                                      returnClass:NULL
                                   containedClass:NULL
                                          jsonKey:&jsonKey]) {
    NSNumber *num = [self JSONValueForKey:jsonKey];
    num = GTL_EnsureNSNumber(num);
    double result = [num doubleValue];
    return result;
  }
  return 0.0;
}

static void DynamicDoubleSetter(id self, SEL sel, double val) {
  // save a double (NSNumber) into the JSON dictionary
  NSString *jsonKey = nil;
  Class<GTLRuntimeCommon> selfClass = [self class];
  if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass
                                         selector:sel
                                      returnClass:NULL
                                   containedClass:NULL
                                          jsonKey:&jsonKey]) {
    NSNumber *num = [NSNumber numberWithDouble:val];
    [self setJSONValue:num forKey:jsonKey];
  }
}

// BOOL
static BOOL DynamicBooleanGetter(id self, SEL sel) {
  // get a BOOL (NSNumber) from the JSON dictionary
  NSString *jsonKey = nil;
  Class<GTLRuntimeCommon> selfClass = [self class];
  if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass
                                         selector:sel
                                      returnClass:NULL
                                   containedClass:NULL
                                          jsonKey:&jsonKey]) {
    NSNumber *num = [self JSONValueForKey:jsonKey];
    BOOL flag = [num boolValue];
    return flag;
  }
  return NO;
}

static void DynamicBooleanSetter(id self, SEL sel, BOOL val) {
  // save a BOOL (NSNumber) into the JSON dictionary
  NSString *jsonKey = nil;
  Class<GTLRuntimeCommon> selfClass = [self class];
  if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass
                                         selector:sel
                                      returnClass:NULL
                                   containedClass:NULL
                                          jsonKey:&jsonKey]) {
    NSNumber *num = [NSNumber numberWithBool:val];
    [self setJSONValue:num forKey:jsonKey];
  }
}

// NSString
static NSString *DynamicStringGetter(id<GTLRuntimeCommon> self, SEL sel) {
  // get an NSString from the JSON dictionary
  NSString *jsonKey = nil;
  Class<GTLRuntimeCommon> selfClass = [self class];
  if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass
                                         selector:sel
                                      returnClass:NULL
                                   containedClass:NULL
                                          jsonKey:&jsonKey]) {

    NSString *str = [self JSONValueForKey:jsonKey];
    return str;
  }
  return nil;
}

static void DynamicStringSetter(id<GTLRuntimeCommon> self, SEL sel,
                                NSString *str) {
  // save an NSString into the JSON dictionary
  NSString *jsonKey = nil;
  Class<GTLRuntimeCommon> selfClass = [self class];
  if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass
                                         selector:sel
                                      returnClass:NULL
                                   containedClass:NULL
                                          jsonKey:&jsonKey]) {
    NSString *copiedStr = [str copy];
    [self setJSONValue:copiedStr forKey:jsonKey];
    [copiedStr release];
  }
}

// GTLDateTime
static GTLDateTime *DynamicDateTimeGetter(id<GTLRuntimeCommon> self, SEL sel) {
  // get a GTLDateTime from the JSON dictionary
  NSString *jsonKey = nil;
  Class<GTLRuntimeCommon> selfClass = [self class];
  if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass
                                         selector:sel
                                      returnClass:NULL
                                   containedClass:NULL
                                          jsonKey:&jsonKey]) {

    // Return the cached object before creating on demand.
    GTLDateTime *cachedDateTime = [self cacheChildForKey:jsonKey];
    if (cachedDateTime != nil) {
      return cachedDateTime;
    }
    NSString *str = [self JSONValueForKey:jsonKey];
    id cacheValue, resultValue;
    if (![str isKindOfClass:[NSNull class]]) {
      GTLDateTime *dateTime = [GTLDateTime dateTimeWithRFC3339String:str];

      cacheValue = dateTime;
      resultValue = dateTime;
    } else {
      cacheValue = nil;
      resultValue = [NSNull null];
    }
    [self setCacheChild:cacheValue forKey:jsonKey];
    return resultValue;
  }
  return nil;
}

static void DynamicDateTimeSetter(id<GTLRuntimeCommon> self, SEL sel,
                                  GTLDateTime *dateTime) {
  // save an GTLDateTime into the JSON dictionary
  NSString *jsonKey = nil;
  Class<GTLRuntimeCommon> selfClass = [self class];
  if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass
                                         selector:sel
                                      returnClass:NULL
                                   containedClass:NULL
                                          jsonKey:&jsonKey]) {
    id cacheValue, jsonValue;
    if (![dateTime isKindOfClass:[NSNull class]]) {
      jsonValue = [dateTime stringValue];
      cacheValue = dateTime;
    } else {
      jsonValue = [NSNull null];
      cacheValue = nil;
    }

    [self setJSONValue:jsonValue forKey:jsonKey];
    [self setCacheChild:cacheValue forKey:jsonKey];
  }
}

// NSNumber
static NSNumber *DynamicNumberGetter(id<GTLRuntimeCommon> self, SEL sel) {
  // get an NSNumber from the JSON dictionary
  NSString *jsonKey = nil;
  Class<GTLRuntimeCommon> selfClass = [self class];
  if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass
                                         selector:sel
                                      returnClass:NULL
                                   containedClass:NULL
                                          jsonKey:&jsonKey]) {

    NSNumber *num = [self JSONValueForKey:jsonKey];
    num = GTL_EnsureNSNumber(num);
    return num;
  }
  return nil;
}

static void DynamicNumberSetter(id<GTLRuntimeCommon> self, SEL sel,
                                NSNumber *num) {
  // save an NSNumber into the JSON dictionary
  NSString *jsonKey = nil;
  Class<GTLRuntimeCommon> selfClass = [self class];
  if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass
                                         selector:sel
                                      returnClass:NULL
                                   containedClass:NULL
                                          jsonKey:&jsonKey]) {
    [self setJSONValue:num forKey:jsonKey];
  }
}

// GTLObject
static GTLObject *DynamicObjectGetter(id<GTLRuntimeCommon> self, SEL sel) {
  // get a GTLObject from the JSON dictionary
  NSString *jsonKey = nil;
  Class returnClass = nil;
  Class<GTLRuntimeCommon> selfClass = [self class];
  if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass
                                         selector:sel
                                      returnClass:&returnClass
                                   containedClass:NULL
                                          jsonKey:&jsonKey]) {

    // Return the cached object before creating on demand.
    GTLObject *cachedObj = [self cacheChildForKey:jsonKey];
    if (cachedObj != nil) {
      return cachedObj;
    }
    NSMutableDictionary *dict = [self JSONValueForKey:jsonKey];
    if ([dict isKindOfClass:[NSMutableDictionary class]]) {
      // get the class of the object being returned, and instantiate it
      if (returnClass == Nil) {
        returnClass = [GTLObject class];
      }

      NSDictionary *surrogates = self.surrogates;
      GTLObject *obj = [GTLObject objectForJSON:dict
                                   defaultClass:returnClass
                                     surrogates:surrogates
                                  batchClassMap:nil];
      [self setCacheChild:obj forKey:jsonKey];
      return obj;
    } else if ([dict isKindOfClass:[NSNull class]]) {
      [self setCacheChild:nil forKey:jsonKey];
      return (id) [NSNull null];
    } else if (dict != nil) {
      // unexpected; probably got a string -- let the caller figure it out
      GTL_DEBUG_LOG(@"GTLObject: unexpected JSON: %@.%@ should be a dictionary, actually is a %@:\n%@",
                    NSStringFromClass(selfClass), NSStringFromSelector(sel),
                    NSStringFromClass([dict class]), dict);
      return (GTLObject *)dict;
    }
  }
  return nil;
}

static void DynamicObjectSetter(id<GTLRuntimeCommon> self, SEL sel,
                                GTLObject *obj) {
  // save a GTLObject into the JSON dictionary
  NSString *jsonKey = nil;
  Class<GTLRuntimeCommon> selfClass = [self class];
  if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass
                                         selector:sel
                                      returnClass:NULL
                                   containedClass:NULL
                                          jsonKey:&jsonKey]) {
    id cacheValue, jsonValue;
    if (![obj isKindOfClass:[NSNull class]]) {
      NSMutableDictionary *dict = [obj JSON];
      if (dict == nil && obj != nil) {
        // adding an empty object; it should have a JSON dictionary so it can
        // hold future assignments
        obj.JSON = [NSMutableDictionary dictionary];
        jsonValue = obj.JSON;
      } else {
        jsonValue = dict;
      }
      cacheValue = obj;
    } else {
      jsonValue = [NSNull null];
      cacheValue = nil;
    }
    [self setJSONValue:jsonValue forKey:jsonKey];
    [self setCacheChild:cacheValue forKey:jsonKey];
  }
}

// get an NSArray of GTLObjects, NSStrings, or NSNumbers from the
// JSON dictionary for this object
static NSMutableArray *DynamicArrayGetter(id<GTLRuntimeCommon> self, SEL sel) {
  NSString *jsonKey = nil;
  Class containedClass = nil;
  Class selfClass = [self class];
  if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass
                                         selector:sel
                                      returnClass:NULL
                                   containedClass:&containedClass
                                          jsonKey:&jsonKey]) {

    // Return the cached array before creating on demand.
    NSMutableArray *cachedArray = [self cacheChildForKey:jsonKey];
    if (cachedArray != nil) {
      return cachedArray;
    }
    NSMutableArray *result = nil;
    NSArray *array = [self JSONValueForKey:jsonKey];
    if (array != nil) {
      if ([array isKindOfClass:[NSArray class]]) {
        NSDictionary *surrogates = self.surrogates;
        result = [GTLRuntimeCommon objectFromJSON:array
                                     defaultClass:containedClass
                                       surrogates:surrogates
                                      isCacheable:NULL];
      } else {
#if DEBUG
        if (![array isKindOfClass:[NSNull class]]) {
          GTL_DEBUG_LOG(@"GTLObject: unexpected JSON: %@.%@ should be an array, actually is a %@:\n%@",
                        NSStringFromClass(selfClass), NSStringFromSelector(sel),
                        NSStringFromClass([array class]), array);
        }
#endif
        result = (NSMutableArray *)array;
      }
    }

    [self setCacheChild:result forKey:jsonKey];
    return result;
  }
  return nil;
}

static void DynamicArraySetter(id<GTLRuntimeCommon> self, SEL sel,
                               NSMutableArray *array) {
  // save an array of GTLObjects objects into the JSON dictionary
  NSString *jsonKey = nil;
  Class selfClass = [self class];
  Class containedClass = nil;
  if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass
                                         selector:sel
                                      returnClass:NULL
                                   containedClass:&containedClass
                                          jsonKey:&jsonKey]) {
    id json = [GTLRuntimeCommon jsonFromAPIObject:array
                                    expectedClass:containedClass
                                      isCacheable:NULL];
    [self setJSONValue:json forKey:jsonKey];
    [self setCacheChild:array forKey:jsonKey];
  }
}

// type 'id'
static id DynamicNSObjectGetter(id<GTLRuntimeCommon> self, SEL sel) {
  NSString *jsonKey = nil;
  Class returnClass = nil;
  Class selfClass = [self class];
  if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass
                                         selector:sel
                                      returnClass:&returnClass
                                   containedClass:NULL
                                          jsonKey:&jsonKey]) {

    // Return the cached object before creating on demand.
    id cachedObj = [self cacheChildForKey:jsonKey];
    if (cachedObj != nil) {
      return cachedObj;
    }

    id jsonObj = [self JSONValueForKey:jsonKey];
    if (jsonObj != nil) {
      BOOL shouldCache = NO;
      NSDictionary *surrogates = self.surrogates;
      id result = [GTLRuntimeCommon objectFromJSON:jsonObj
                                      defaultClass:nil
                                        surrogates:surrogates
                                       isCacheable:&shouldCache];

      [self setCacheChild:(shouldCache ? result : nil)
                   forKey:jsonKey];
      return result;
    }
  }
  return nil;
}

static void DynamicNSObjectSetter(id<GTLRuntimeCommon> self, SEL sel, id obj) {
  NSString *jsonKey = nil;
  Class selfClass = [self class];
  if ([GTLRuntimeCommon getStoredDispatchForClass:selfClass
                                         selector:sel
                                      returnClass:NULL
                                   containedClass:NULL
                                          jsonKey:&jsonKey]) {
    BOOL shouldCache = NO;
    id json = [GTLRuntimeCommon jsonFromAPIObject:obj
                                    expectedClass:Nil
                                      isCacheable:&shouldCache];
    [self setJSONValue:json forKey:jsonKey];
    [self setCacheChild:(shouldCache ? obj : nil)
                 forKey:jsonKey];
  }
}

#pragma mark Runtime lookup support

static objc_property_t PropertyForSel(Class<GTLRuntimeCommon> startClass,
                                      SEL sel, BOOL isSetter,
                                      Class<GTLRuntimeCommon> *outFoundClass) {
  const char *baseName = sel_getName(sel);
  size_t baseNameLen = strlen(baseName);
  if (isSetter) {
    baseName += 3;    // skip "set"
    baseNameLen -= 4; // subtract "set" and the final colon
  }

  // walk from this class up the hierarchy to the ancestor class
  Class<GTLRuntimeCommon> topClass = class_getSuperclass([startClass ancestorClass]);
  for (Class currClass = startClass;
       currClass != topClass;
       currClass = class_getSuperclass(currClass)) {
    // step through this class's properties
    objc_property_t foundProp = NULL;
    objc_property_t *properties = class_copyPropertyList(currClass, NULL);
    if (properties) {
      for (objc_property_t *prop = properties; *prop != NULL; ++prop) {
        const char *propName = property_getName(*prop);
        size_t propNameLen = strlen(propName);

        // search for an exact-name match (a getter), but case-insensitive on the
        // first character (in case baseName comes from a setter)
        if (baseNameLen == propNameLen
            && strncasecmp(baseName, propName, 1) == 0
            && (baseNameLen <= 1
                || strncmp(baseName + 1, propName + 1, baseNameLen - 1) == 0)) {
              // return the actual property name
              foundProp = *prop;

              // if requested, return the class containing the property
              if (outFoundClass) *outFoundClass = currClass;
              break;
            }
      }
      free(properties);
    }
    if (foundProp) return foundProp;
  }

  // not found; this occasionally happens when the system looks for a method
  // like "getFoo" or "descriptionWithLocale:indent:"
  return NULL;
}

typedef struct {
  const char *attributePrefix;

  const char *setterEncoding;
  IMP         setterFunction;
  const char *getterEncoding;
  IMP         getterFunction;

  // These are the "fixed" return classes, but some properties will require
  // looking up the return class instead (because it is a subclass of
  // GTLObject).
  const char *returnClassName;
  Class       returnClass;
  BOOL extractReturnClass;

} GTLDynamicImpInfo;

static const GTLDynamicImpInfo *DynamicImpInfoForProperty(objc_property_t prop,
                                                          Class *outReturnClass) {

  if (outReturnClass) *outReturnClass = nil;

  // dynamic method resolution:
  // http://developer.apple.com/library/ios/#documentation/Cocoa/Conceptual/ObjCRuntimeGuide/Articles/ocrtDynamicResolution.html
  //
  // property runtimes:
  // http://developer.apple.com/library/ios/#documentation/Cocoa/Conceptual/ObjCRuntimeGuide/Articles/ocrtPropertyIntrospection.html

  // Get and parse the property attributes, which look something like
  //   T@"NSString",&,D,P
  //   Ti,D -- NSInteger on 32bit
  //   Tq,D -- NSInteger on 64bit, long long on 32bit & 64bit
  //   Tc,D -- BOOL comes as char
  //   T@"NSString",D
  //   T@"GTLLink",D
  //   T@"NSArray",D


  static GTLDynamicImpInfo kImplInfo[] = {
#if !__LP64__
    { // NSInteger on 32bit
      "Ti",
      "v@:i", (IMP)DynamicInteger32Setter,
      "i@:", (IMP)DynamicInteger32Getter,
      nil, nil,
      NO
    },
    { // NSUInteger on 32bit
      "TI",
      "v@:I", (IMP)DynamicUInteger32Setter,
      "I@:", (IMP)DynamicUInteger32Getter,
      nil, nil,
      NO
    },
#endif
    { // NSInteger on 64bit, long long on 32bit and 64bit.
      "Tq",
      "v@:q", (IMP)DynamicLongLongSetter,
      "q@:", (IMP)DynamicLongLongGetter,
      nil, nil,
      NO
    },
    { // NSUInteger on 64bit, long long on 32bit and 64bit.
      "TQ",
      "v@:Q", (IMP)DynamicULongLongSetter,
      "Q@:", (IMP)DynamicULongLongGetter,
      nil, nil,
      NO
    },
    { // float
      "Tf",
      "v@:f", (IMP)DynamicFloatSetter,
      "f@:", (IMP)DynamicFloatGetter,
      nil, nil,
      NO
    },
    { // double
      "Td",
      "v@:d", (IMP)DynamicDoubleSetter,
      "d@:", (IMP)DynamicDoubleGetter,
      nil, nil,
      NO
    },
    { // BOOL
      "Tc",
      "v@:c", (IMP)DynamicBooleanSetter,
      "c@:", (IMP)DynamicBooleanGetter,
      nil, nil,
      NO
    },
    { // NSString
      "T@\"NSString\"",
      "v@:@", (IMP)DynamicStringSetter,
      "@@:", (IMP)DynamicStringGetter,
      "NSString", nil,
      NO
    },
    { // NSNumber
      "T@\"NSNumber\"",
      "v@:@", (IMP)DynamicNumberSetter,
      "@@:", (IMP)DynamicNumberGetter,
      "NSNumber", nil,
      NO
    },
    { // GTLDateTime
#if !defined(GTL_TARGET_NAMESPACE)
      "T@\"GTLDateTime\"",
      "v@:@", (IMP)DynamicDateTimeSetter,
      "@@:", (IMP)DynamicDateTimeGetter,
      "GTLDateTime", nil,
      NO
#else
      "T@\"" GTL_TARGET_NAMESPACE_STRING "_" "GTLDateTime\"",
      "v@:@", (IMP)DynamicDateTimeSetter,
      "@@:", (IMP)DynamicDateTimeGetter,
      GTL_TARGET_NAMESPACE_STRING "_" "GTLDateTime", nil,
      NO
#endif
    },
    { // NSArray with type
      "T@\"NSArray\"",
      "v@:@", (IMP)DynamicArraySetter,
      "@@:", (IMP)DynamicArrayGetter,
      "NSArray", nil,
      NO
    },
    { // id (any of the objects above)
      "T@,",
      "v@:@", (IMP)DynamicNSObjectSetter,
      "@@:", (IMP)DynamicNSObjectGetter,
      "NSObject", nil,
      NO
    },
    { // GTLObject - Last, cause it's a special case and prefix is general
      "T@\"",
      "v@:@", (IMP)DynamicObjectSetter,
      "@@:", (IMP)DynamicObjectGetter,
      nil, nil,
      YES
    },
  };

  static BOOL hasLookedUpClasses = NO;
  if (!hasLookedUpClasses) {
    // Unfortunately, you can't put [NSString class] into the static structure,
    // so this lookup has to be done at runtime.
    hasLookedUpClasses = YES;
    for (uint32_t idx = 0; idx < sizeof(kImplInfo)/sizeof(kImplInfo[0]); ++idx) {
      if (kImplInfo[idx].returnClassName) {
        kImplInfo[idx].returnClass = objc_getClass(kImplInfo[idx].returnClassName);
        NSCAssert1(kImplInfo[idx].returnClass != nil,
                   @"GTLRuntimeCommon: class lookup failed: %s", kImplInfo[idx].returnClassName);
      }
    }
  }

  const char *attr = property_getAttributes(prop);

  const char *dynamicMarker = strstr(attr, ",D");
  if (!dynamicMarker ||
      (dynamicMarker[2] != 0 && dynamicMarker[2] != ',' )) {
    GTL_DEBUG_LOG(@"GTLRuntimeCommon: property %s isn't dynamic, attributes %s",
                  property_getName(prop), attr ? attr : "(nil)");
    return NULL;
  }

  const GTLDynamicImpInfo *result = NULL;

  // Cycle over the list

  for (uint32_t idx = 0; idx < sizeof(kImplInfo)/sizeof(kImplInfo[0]); ++idx) {
    const char *attributePrefix = kImplInfo[idx].attributePrefix;
    if (strncmp(attr, attributePrefix, strlen(attributePrefix)) == 0) {
      result = &kImplInfo[idx];
      if (outReturnClass) *outReturnClass = result->returnClass;
      break;
    }
  }

  if (result == NULL) {
    GTL_DEBUG_LOG(@"GTLRuntimeCommon: unexpected attributes %s for property %s",
                  attr ? attr : "(nil)", property_getName(prop));
    return NULL;
  }

  if (result->extractReturnClass && outReturnClass) {

    // add a null at the next quotation mark
    char *attrCopy = strdup(attr);
    char *classNameStart = attrCopy + 3;
    char *classNameEnd = strstr(classNameStart, "\"");
    if (classNameEnd) {
      *classNameEnd = '\0';

      // Lookup the return class
      *outReturnClass = objc_getClass(classNameStart);
      if (*outReturnClass == nil) {
        GTL_DEBUG_LOG(@"GTLRuntimeCommon: did not find class with name \"%s\" "
                      "for property \"%s\" with attributes \"%s\"",
                      classNameStart, property_getName(prop), attr);
      }
    } else {
      GTL_DEBUG_LOG(@"GTLRuntimeCommon: Failed to find end of class name for "
                    "property \"%s\" with attributes \"%s\"",
                    property_getName(prop), attr);
    }
    free(attrCopy);
  }

  return result;
}

#pragma mark Runtime - wiring point

+ (BOOL)resolveInstanceMethod:(SEL)sel onClass:(Class<GTLRuntimeCommon>)onClass {
  // dynamic method resolution:
  // http://developer.apple.com/library/ios/#documentation/Cocoa/Conceptual/ObjCRuntimeGuide/Articles/ocrtDynamicResolution.html
  //
  // property runtimes:
  // http://developer.apple.com/library/ios/#documentation/Cocoa/Conceptual/ObjCRuntimeGuide/Articles/ocrtPropertyIntrospection.html

  const char *selName = sel_getName(sel);
  size_t selNameLen = strlen(selName);
  char lastChar = selName[selNameLen - 1];
  BOOL isSetter = (lastChar == ':');

  // look for a declared property matching this selector name exactly
  Class<GTLRuntimeCommon> foundClass = nil;

  objc_property_t prop = PropertyForSel(onClass, sel, isSetter, &foundClass);
  if (prop != NULL && foundClass != nil) {

    Class returnClass = nil;
    const GTLDynamicImpInfo *implInfo = DynamicImpInfoForProperty(prop,
                                                                  &returnClass);
    if (implInfo == NULL) {
      GTL_DEBUG_LOG(@"GTLRuntimeCommon: unexpected return type class %s for "
                      "property \"%s\" of class \"%s\"",
                      returnClass ? class_getName(returnClass) : "<nil>",
                      property_getName(prop),
                      class_getName(onClass));
    }

    if (implInfo != NULL) {
      IMP imp = ( isSetter ? implInfo->setterFunction : implInfo->getterFunction );
      const char *encoding = ( isSetter ? implInfo->setterEncoding : implInfo->getterEncoding );

      class_addMethod(foundClass, sel, imp, encoding);

      const char *propName = property_getName(prop);
      NSString *propStr = [NSString stringWithUTF8String:propName];

      // replace the property name with the proper JSON key if it's
      // special-cased with a map in the found class; otherwise, the property
      // name is the JSON key
      NSDictionary *keyMap =
        [[foundClass ancestorClass] propertyToJSONKeyMapForClass:foundClass];
      NSString *jsonKey = [keyMap objectForKey:propStr];
      if (jsonKey == nil) {
        jsonKey = propStr;
      }

      Class containedClass = nil;

      // For arrays we need to look up what the contained class is.
      if (imp == (IMP)DynamicArraySetter || imp == (IMP)DynamicArrayGetter) {
        NSDictionary *classMap =
          [[foundClass ancestorClass] arrayPropertyToClassMapForClass:foundClass];
        containedClass = [classMap objectForKey:jsonKey];
        if (containedClass == Nil) {
          GTL_DEBUG_LOG(@"GTLRuntimeCommon: expected array item class for "
                        "property \"%s\" of class \"%s\"",
                        property_getName(prop), class_getName(foundClass));
        }
      }

      // save the dispatch info to the cache
      [GTLRuntimeCommon setStoredDispatchForClass:foundClass
                                         selector:sel
                                      returnClass:returnClass
                                   containedClass:containedClass
                                          jsonKey:jsonKey];
      return YES;
    }
  }

  return NO;
}

@end