NSKeyValueObserving.m

时间：2022-11-07 14:11:38

https://github.com/farcaller/cocotron/blob/af740de86c9bee84c59ffc74d27e5df9e22e1391/Foundation/NSKeyValueCoding/NSKeyValueObserving.m

/* Copyright (c) 2007-2008 Johannes Fortmann
   
  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
   
  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
   
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
   
  #import <Foundation/NSKeyValueObserving.h>
  #import <Foundation/NSArray.h>
  #import <Foundation/NSSet.h>
  #import <Foundation/NSDictionary.h>
  #import <Foundation/NSLock.h>
  #import <Foundation/NSValue.h>
  #import <Foundation/NSException.h>
  #import <Foundation/NSEnumerator.h>
  #import <Foundation/NSKeyValueCoding.h>
  #import <Foundation/NSMethodSignature.h>
  #import <Foundation/NSIndexSet.h>
  #import <Foundation/NSDebug.h>
   
  #import <objc/objc-runtime.h>
  #import <objc/objc-class.h>
  #import <string.h>
  #import <ctype.h>
   
  #import "NSString+KVCAdditions.h"
  #import "NSKeyValueObserving-Private.h"
   
  NSString *const NSKeyValueChangeKindKey=@"NSKeyValueChangeKindKey";
  NSString *const NSKeyValueChangeNewKey=@"NSKeyValueChangeNewKey";
  NSString *const NSKeyValueChangeOldKey=@"NSKeyValueChangeOldKey";
  NSString *const NSKeyValueChangeIndexesKey=@"NSKeyValueChangeIndexesKey";
  NSString *const NSKeyValueChangeNotificationIsPriorKey=@"NSKeyValueChangeNotificationIsPriorKey";
   
  NSString *const _KVO_DependentKeysTriggeringChangeNotification=@"_KVO_DependentKeysTriggeringChangeNotification";
  NSString *const _KVO_KeyPathsForValuesAffectingValueForKey=@"_KVO_KeyPathsForValuesAffectingValueForKey";
   
  #pragma mark -
  #pragma mark KVO implementation
   
  static NSMutableDictionary *observationInfos=nil;
  static NSLock *kvoLock=nil;
   
  @interface NSObject (KVOSettersForwardReferencs)
  +(void)_KVO_buildDependencyUnion;
  @end
   
  @interface NSObject (KVCPrivateMethod)
  -(void)_demangleTypeEncoding:(const char*)type to:(char*)cleanType;
  @end
   
  @implementation NSObject (KeyValueObserving)
   
  -(void*)observationInfo
  {
  return [[observationInfos objectForKey:[NSValue valueWithPointer:self]] pointerValue];
  }
   
  -(void)setObservationInfo:(void*)info
  {
  if(!observationInfos)
  observationInfos=[NSMutableDictionary new];
  [observationInfos setObject:[NSValue valueWithPointer:info] forKey:[NSValue valueWithPointer:self]];
  }
   
  +(void*)observationInfo
  {
  return [[observationInfos objectForKey:[NSValue valueWithPointer:self]] pointerValue];
  }
   
  +(void)setObservationInfo:(void*)info
  {
  if(!observationInfos)
  observationInfos=[NSMutableDictionary new];
  [observationInfos setObject:[NSValue valueWithPointer:info] forKey:[NSValue valueWithPointer:self]];
  }
   
  -(void)addObserver:(id)observer forKeyPath:(NSString*)keyPath options:(NSKeyValueObservingOptions)options context:(void*)context;
  {
  [self _KVO_swizzle];
  NSString* remainingKeyPath;
  NSString* key;
  [keyPath _KVC_partBeforeDot:&key afterDot:&remainingKeyPath];
   
  if([keyPath hasPrefix:@"@"]) {
  // the key path is an operator: don't evaluate
  key=keyPath;
  remainingKeyPath=nil;
  }
   
  // get observation info dictionary
  NSMutableDictionary* observationInfo=[self observationInfo];
  // get all observers for current key
  NSMutableArray *observers=[observationInfo objectForKey:key];
   
  // find if already observing
  _NSObservationInfo *oldInfo=nil;
  for(_NSObservationInfo *current in observers) {
  if(current->observer==observer &&
  [[current keyPath] isEqualToString:keyPath]) {
  oldInfo=current;
  break;
  }
  }
   
  // create new info
  _NSObservationInfo *info=nil;
  if(oldInfo)
  info=oldInfo;
  else
  info=[[_NSObservationInfo new] autorelease];
   
  // We now add the observer to the rest of the path, then to the dependents.
  // Any of the following may fail if a key path doesn't exist.
  // We have to keep track of how far we have come to be able to roll back.
  id lastPathTried=nil;
  NSSet* dependentPathsForKey=[isa keyPathsForValuesAffectingValueForKey:key];
  @try {
  // if observing a key path, also observe all deeper levels
  // info object acts as a proxy replacing remainingKeyPath with keyPath
  if([remainingKeyPath length])
  {
  lastPathTried=remainingKeyPath;
  [[self valueForKey:key] addObserver:info
  forKeyPath:remainingKeyPath
  options:options
  context:context];
  }
   
  // now try all dependent key paths
  for(NSString *path in dependentPathsForKey)
  {
  lastPathTried=path;
  [self addObserver:info
  forKeyPath:path
  options:options
  context:context];
  }
  }
  @catch(id ex) {
  // something went wrong. rollback all the work we've done so far.
  BOOL wasInDependentKey=NO;
   
  if(lastPathTried!=remainingKeyPath) {
  wasInDependentKey=YES;
  // adding to a dependent path failed. roll back for all the paths before.
  if([remainingKeyPath length]) {
  [[self valueForKey:key] removeObserver:info forKeyPath:remainingKeyPath];
  }
   
  for(NSString *path in dependentPathsForKey)
  {
  if(path==lastPathTried)
  break; // this is the one that failed
  [self removeObserver:info forKeyPath:path];
  }
  }
   
  // reformat exceptions to be more expressive
  if([[ex name] isEqualToString:NSUndefinedKeyException]) {
  if(!wasInDependentKey) {
  [NSException raise:NSUndefinedKeyException
  format:@"Undefined key while adding observer for key path %@ to object %p", keyPath, self];
  }
  else {
  [NSException raise:NSUndefinedKeyException
  format:@"Undefined key while adding observer for dependent key path %@ of path %@ to object %p", lastPathTried, keyPath, self];
  }
  }
  [ex raise];
  }
   
   
  // we were able to observe the full length of our key path, and the dependents.
  // now make the changes to our own observers array
   
  // create observation info dictionary if it's not there
  // (we have to re-check: it may have been created while observing our dependents
  if(!observationInfo && !(observationInfo = [self observationInfo]))
  {
  [self setObservationInfo:[NSMutableDictionary new]];
  observationInfo=[self observationInfo];
  observers = [observationInfo objectForKey:key];
  }
   
  // get all observers for current key
  if(!observers)
  {
  observers = [NSMutableArray array];
  [observationInfo setObject:observers forKey:key];
  }
   
  // set info options
  info->observer=observer;
  info->options=options;
  info->context=context;
  info->object=self;
  [info setKeyPath:keyPath];
   
  if(!oldInfo) {
  [observers addObject:info];
  }
   
   
  if(options & NSKeyValueObservingOptionInitial)
  {
  [self willChangeValueForKey:keyPath];
  [self didChangeValueForKey:keyPath];
  }
  }
   
   
  -(void)removeObserver:(id)observer forKeyPath:(NSString*)keyPath;
  {
  NSString* key, *remainingKeyPath;
  [keyPath _KVC_partBeforeDot:&key afterDot:&remainingKeyPath];
   
  if([keyPath hasPrefix:@"@"]) {
  // the key path is an operator: don't evaluate
  key=keyPath;
  remainingKeyPath=nil;
  }
   
  // now remove own observer
  NSMutableDictionary* observationInfo=[self observationInfo];
  NSMutableArray *observers=[observationInfo objectForKey:key];
   
  for(_NSObservationInfo *info in [[observers copy] autorelease])
  {
  if(info->observer==observer &&
  [[info keyPath] isEqualToString:keyPath])
  {
  [[info retain] autorelease];
  [observers removeObject:info];
  if(![observers count])
  {
  [observationInfo removeObjectForKey:key];
  }
  if(![observationInfo count])
  {
  [self setObservationInfo:nil];
  [observationInfo release];
  }
   
  if([remainingKeyPath length])
  [[self valueForKey:key] removeObserver:info forKeyPath:remainingKeyPath];
   
  NSSet* keysPathsForKey=[isa keyPathsForValuesAffectingValueForKey:key];
  for(NSString *path in keysPathsForKey)
  {
  [self removeObserver:info
  forKeyPath:path];
  }
   
  return;
  }
  }
  // 10.4 Apple implementation will crash at this point...
  [NSException raise:@"NSKVOException" format:@"trying to remove observer %@ for unobserved key path %@", observer, keyPath];
  }
   
  -(void)willChangeValueForKey:(NSString*)key
  {
  NSMutableDictionary *dict=[NSMutableDictionary new];
  [dict setObject:[NSNumber numberWithInt:NSKeyValueChangeSetting]
  forKey:NSKeyValueChangeKindKey];
  [self _willChangeValueForKey:key changeOptions:dict];
  [dict release];
  }
   
  -(void)didChangeValueForKey:(NSString*)key
  {
  [self _didChangeValueForKey:key changeOptions:nil];
  }
   
  - (void)willChange:(NSKeyValueChange)change valuesAtIndexes:(NSIndexSet *)indexes forKey:(NSString *)key
  {
  NSMutableDictionary *dict=[NSMutableDictionary new];
  [dict setObject:[NSNumber numberWithUnsignedInteger:change]
  forKey:NSKeyValueChangeKindKey];
  [dict setObject:indexes
  forKey:NSKeyValueChangeIndexesKey];
  [self _willChangeValueForKey:key changeOptions:dict];
  [dict release];
  }
   
  - (void)didChange:(NSKeyValueChange)change valuesAtIndexes:(NSIndexSet *)indexes forKey:(NSString *)key
  {
  [self _didChangeValueForKey:key changeOptions:nil];
  }
   
   
  #pragma mark Observer notification
   
  -(void)_willChangeValueForKey:(NSString*)key changeOptions:(NSDictionary*)changeOptions
  {
  NSMutableDictionary* observationInfo=[self observationInfo];
   
  if(!observationInfo)
  return;
   
  NSMutableArray *observers=[observationInfo objectForKey:key];
   
  for(_NSObservationInfo *info in [[observers copy] autorelease])
  {
  // increment change count for nested did/willChangeValue's
  info->willChangeCount++;
  if(info->willChangeCount>1)
  continue;
  NSString* keyPath=info->keyPath;
   
  if(![info changeDictionary])
  {
  id cd=[changeOptions mutableCopy];
  [info setChangeDictionary:cd];
  [cd release];
  }
   
  // store old value if applicable
  if(info->options & NSKeyValueObservingOptionOld)
  {
  id idxs=[info->changeDictionary objectForKey:NSKeyValueChangeIndexesKey];
   
  if(idxs)
  {
  int type=[[info->changeDictionary objectForKey:NSKeyValueChangeKindKey] intValue];
  // for to-many relationships, oldvalue is only sensible for replace and remove
  if(type == NSKeyValueChangeReplacement ||
  type == NSKeyValueChangeRemoval)
  [info->changeDictionary setValue:[[self mutableArrayValueForKeyPath:keyPath] objectsAtIndexes:idxs] forKey:NSKeyValueChangeOldKey];
  }
  else
  {
  [info->changeDictionary setValue:[self valueForKeyPath:keyPath] forKey:NSKeyValueChangeOldKey];
  }
  }
   
  // inform observer of change
  if(info->options & NSKeyValueObservingOptionPrior)
  {
  [info->changeDictionary setObject:[NSNumber numberWithBool:YES]
  forKey:NSKeyValueChangeNotificationIsPriorKey];
  [info->observer observeValueForKeyPath:info->keyPath
  ofObject:self
  change:info->changeDictionary
  context:info->context];
  [info->changeDictionary removeObjectForKey:NSKeyValueChangeNotificationIsPriorKey];
  }
   
  NSString* firstPart, *rest;
  [keyPath _KVC_partBeforeDot:&firstPart afterDot:&rest];
   
  if([keyPath hasPrefix:@"@"]) {
  // the key path is an operator: don't evaluate
  key=keyPath;
  rest=nil;
  }
   
  // remove deeper levels (those items will change)
  if(rest)
  [[self valueForKey:firstPart] removeObserver:info forKeyPath:rest];
  }
  }
   
  -(void)_didChangeValueForKey:(NSString*)key changeOptions:(NSDictionary*)ignored
  {
  NSMutableDictionary* observationInfo=[self observationInfo];
   
  if(!observationInfo)
  return;
   
  NSMutableArray *observers=[[observationInfo objectForKey:key] copy];
   
  for(_NSObservationInfo *info in observers)
  {
  // decrement count and only notify after last didChange
  info->willChangeCount--;
  if(info->willChangeCount>0)
  continue;
  NSString* keyPath=info->keyPath;
   
  // store new value if applicable
  if(info->options & NSKeyValueObservingOptionNew)
  {
  id idxs=[info->changeDictionary objectForKey:NSKeyValueChangeIndexesKey];
  if(idxs)
  {
  int type=[[info->changeDictionary objectForKey:NSKeyValueChangeKindKey] intValue];
  // for to-many relationships, newvalue is only sensible for replace and insert
   
  if(type == NSKeyValueChangeReplacement ||
  type == NSKeyValueChangeInsertion)
  [info->changeDictionary setValue:[[self mutableArrayValueForKeyPath:keyPath] objectsAtIndexes:idxs] forKey:NSKeyValueChangeNewKey];
  }
  else
  {
  [info->changeDictionary setValue:[self valueForKeyPath:keyPath] forKey:NSKeyValueChangeNewKey];
  }
  }
   
  // restore deeper observers if applicable
  NSString* firstPart, *rest;
  [keyPath _KVC_partBeforeDot:&firstPart afterDot:&rest];
   
  if([keyPath hasPrefix:@"@"]) {
  // the key path is an operator: don't evaluate
  key=keyPath;
  rest=nil;
  }
   
  if(rest)
  {
  [[self valueForKey:firstPart]
  addObserver:info
  forKeyPath:rest
  options:info->options
  context:info->context];
  }
   
  // inform observer of change
  [info->observer observeValueForKeyPath:info->keyPath
  ofObject:self
  change:info->changeDictionary
  context:info->context];
   
  [info setChangeDictionary:nil];
  }
  [observers release];
  }
   
  +(void)setKeys:(NSArray *)keys triggerChangeNotificationsForDependentKey:(NSString *)dependentKey
  {
  NSMutableDictionary* observationInfo=[self observationInfo];
  if(!observationInfo)
  {
  observationInfo=[NSMutableDictionary new];
  [self setObservationInfo:observationInfo];
  }
   
  NSMutableDictionary *dependencies=[observationInfo objectForKey:_KVO_DependentKeysTriggeringChangeNotification];
  if(!dependencies)
  {
  dependencies=[NSMutableDictionary dictionary];
  [observationInfo setObject:dependencies
  forKey:_KVO_DependentKeysTriggeringChangeNotification];
  }
   
  id key;
  id en=[keys objectEnumerator];
  while((key = [en nextObject]))
  {
  NSMutableSet* allDependencies=[dependencies objectForKey:key];
  if(!allDependencies)
  {
  allDependencies=[NSMutableSet new];
  [dependencies setObject:allDependencies
  forKey:key];
  [allDependencies release];
  }
  [allDependencies addObject:dependentKey];
  }
  }
   
  + (NSSet *)keyPathsForValuesAffectingValueForKey:(NSString *)key
  {
  NSString *methodName=[[NSString alloc] initWithFormat:@"keyPathsForValuesAffecting%@", [key capitalizedString]];
  NSSet* ret=nil;
  SEL sel=NSSelectorFromString(methodName);
  if([self respondsToSelector:sel])
  {
  ret=[self performSelector:sel];
  }
  else
  {
  [self _KVO_buildDependencyUnion];
  NSMutableDictionary* observationInfo=[self observationInfo];
  NSMutableDictionary *keyPathsByKey=[observationInfo objectForKey:_KVO_KeyPathsForValuesAffectingValueForKey];
  ret=[keyPathsByKey objectForKey:key];
  }
  [methodName release];
  return ret;
  }
  @end
   
   
  #pragma mark -
  #pragma mark KVO-notifying setters and swizzeling code
  /* The following functions define suitable setters and getters which
  call willChangeValueForKey: and didChangeValueForKey: on their superclass
  _KVO_swizzle changes the class of its object to a subclass which overrides
  each setter with a suitable KVO-Notifying one.
  */
   
  // selector for change type
  #define CHANGE_SELECTOR(type) KVO_notifying_change_ ## type :
   
  // definition for change type
  #define CHANGE_DEFINE(type) -( void ) KVO_notifying_change_ ## type : ( type ) value
   
  // original selector called by swizzled selector
  #define ORIGINAL_SELECTOR(name) NSSelectorFromString([NSString stringWithFormat:@"_original_%@", name])
   
  // declaration of change function:
  // extracts key from selector called, calls original function
  #define CHANGE_DECLARATION(type) CHANGE_DEFINE(type) \
  { \
  const char* origName = sel_getName(_cmd); \
  size_t selLen=strlen(origName); \
  char *sel=__builtin_alloca(selLen+1); \
  strcpy(sel, origName); \
  sel[selLen-1]='\0'; \
  if(sel[0]=='_') \
  sel+=4; \
  else \
  sel+=3; \
  sel[0]=tolower(sel[0]); \
  NSString *key=[[NSString alloc] initWithCString:sel]; \
  [self willChangeValueForKey:key]; \
  typedef id (*sender)(id obj, SEL selector, type value); \
  sender implementation=(sender)[[self superclass] instanceMethodForSelector:_cmd]; \
  (void)*implementation(self, _cmd, value); \
  [self didChangeValueForKey:key]; \
  [key release]; \
  }
   
   
  // FIX: add more types
  @interface NSObject (KVOSetters)
  CHANGE_DEFINE(float);
  CHANGE_DEFINE(double);
  CHANGE_DEFINE(id);
  CHANGE_DEFINE(int);
  CHANGE_DEFINE(NSSize);
  CHANGE_DEFINE(NSPoint);
  CHANGE_DEFINE(NSRect);
  CHANGE_DEFINE(NSRange);
  CHANGE_DEFINE(char);
  CHANGE_DEFINE(long);
  CHANGE_DEFINE(SEL);
  @end
   
  @implementation NSObject (KVOSetters)
  CHANGE_DECLARATION(float)
  CHANGE_DECLARATION(double)
  CHANGE_DECLARATION(id)
  CHANGE_DECLARATION(int)
  CHANGE_DECLARATION(NSSize)
  CHANGE_DECLARATION(NSPoint)
  CHANGE_DECLARATION(NSRect)
  CHANGE_DECLARATION(NSRange)
  CHANGE_DECLARATION(char)
  CHANGE_DECLARATION(long)
  CHANGE_DECLARATION(SEL)
   
  -(void)KVO_notifying_change_setObject:(id)object forKey:(NSString*)key
  {
  [self willChangeValueForKey:key];
  typedef id (*sender)(id obj, SEL selector, id object, id key);
  sender implementation=(sender)[[self superclass] instanceMethodForSelector:_cmd];
  implementation(self, _cmd, object, key);
  [self didChangeValueForKey:key];
  }
   
  -(void)KVO_notifying_change_removeObjectForKey:(NSString*)key
  {
  [self willChangeValueForKey:key];
  typedef id (*sender)(id obj, SEL selector, id key);
  sender implementation=(sender)[[self superclass] instanceMethodForSelector:_cmd];
  implementation(self, _cmd, key);
  [self didChangeValueForKey:key];
  }
   
   
  -(void)KVO_notifying_change_insertObject:(id)object inKeyAtIndex:(NSInteger)index
  {
  const char* origName = sel_getName(_cmd);
   
  size_t selLen=strlen(origName);
  char *sel=__builtin_alloca(selLen+1);
  strcpy(sel, origName);
  sel[selLen-1]='\0';
  sel+=strlen("insertObject:in");
  sel[strlen(sel)-strlen("AtIndex:")+1]='\0';
   
  sel[0]=tolower(sel[0]);
   
  NSString *key=[[NSString alloc] initWithCString:sel];
  [self willChange:NSKeyValueChangeInsertion valuesAtIndexes:[NSIndexSet indexSetWithIndex:index] forKey:key];
  typedef id (*sender)(id obj, SEL selector, id value, NSInteger index);
  sender implementation=(sender)[[self superclass] instanceMethodForSelector:_cmd];
  (void)*implementation(self, _cmd, object, index);
  [self didChange:NSKeyValueChangeInsertion valuesAtIndexes:[NSIndexSet indexSetWithIndex:index] forKey:key];
  [key release];
  }
   
  -(void)KVO_notifying_change_addKeyObject:(id)object
  {
  const char* origName = sel_getName(_cmd);
   
  size_t selLen=strlen(origName);
  char *sel=__builtin_alloca(selLen+1);
  strcpy(sel, origName);
  sel[selLen-1]='\0';
  sel+=strlen("add");
  sel[strlen(sel)-strlen("Object:")+1]='\0';
   
  char *countSelName=__builtin_alloca(strlen(sel)+strlen("countOf")+1);
  strcpy(countSelName, "countOf");
  strcat(countSelName, sel);
   
  NSUInteger idx=(NSUInteger)[self performSelector:sel_getUid(countSelName)];
   
  sel[0]=tolower(sel[0]);
   
  NSString *key=[[NSString alloc] initWithCString:sel];
  [self willChange:NSKeyValueChangeInsertion valuesAtIndexes:[NSIndexSet indexSetWithIndex:idx] forKey:key];
  typedef id (*sender)(id obj, SEL selector, id value);
  sender implementation=(sender)[[self superclass] instanceMethodForSelector:_cmd];
  (void)*implementation(self, _cmd, object);
  [self didChange:NSKeyValueChangeInsertion valuesAtIndexes:[NSIndexSet indexSetWithIndex:idx] forKey:key];
  [key release];
  }
   
  -(void)KVO_notifying_change_removeKeyObject:(id)object
  {
  const char* origName = sel_getName(_cmd);
   
  size_t selLen=strlen(origName);
  char *sel=__builtin_alloca(selLen+1);
  strcpy(sel, origName);
  sel[selLen-1]='\0';
  sel+=strlen("remove");
  sel[strlen(sel)-strlen("Object:")+1]='\0';
   
  char *countSelName=__builtin_alloca(strlen(sel)+strlen("countOf")+1);
  strcpy(countSelName, "countOf");
  strcat(countSelName, sel);
   
  NSUInteger idx=(NSUInteger)[self performSelector:sel_getUid(countSelName)];
   
  sel[0]=tolower(sel[0]);
   
  NSString *key=[[NSString alloc] initWithCString:sel];
  [self willChange:NSKeyValueChangeRemoval valuesAtIndexes:[NSIndexSet indexSetWithIndex:idx] forKey:key];
  typedef id (*sender)(id obj, SEL selector, id value);
  sender implementation=(sender)[[self superclass] instanceMethodForSelector:_cmd];
  (void)*implementation(self, _cmd, object);
  [self didChange:NSKeyValueChangeRemoval valuesAtIndexes:[NSIndexSet indexSetWithIndex:idx] forKey:key];
  [key release];
  }
   
  -(void)KVO_notifying_change_removeObjectFromKeyAtIndex:(int)index
  {
  const char* origName = sel_getName(_cmd);
  size_t selLen=strlen(origName);
  char *sel=__builtin_alloca(selLen+1);
  strcpy(sel, origName);
  sel[selLen-1]='\0';
  sel+=strlen("removeObjectFrom");
  sel[strlen(sel)-strlen("AtIndex:")+1]='\0';
   
  sel[0]=tolower(sel[0]);
  NSString *key=[[NSString alloc] initWithCString:sel];
  [self willChange:NSKeyValueChangeRemoval valuesAtIndexes:[NSIndexSet indexSetWithIndex:index] forKey:key];
  typedef id (*sender)(id obj, SEL selector, int index);
  sender implementation=(sender)[[self superclass] instanceMethodForSelector:_cmd];
  (void)*implementation(self, _cmd, index);
  [self didChange:NSKeyValueChangeRemoval valuesAtIndexes:[NSIndexSet indexSetWithIndex:index] forKey:key];
  [key release];
  }
   
  -(void)KVO_notifying_change_replaceObjectInKeyAtIndex:(int)index withObject:(id)object
  {
  const char* origName = sel_getName(_cmd);
  size_t selLen=strlen(origName);
  char *sel=__builtin_alloca(selLen+1);
  strcpy(sel, origName);
  sel[selLen-1]='\0';
  sel+=strlen("replaceObjectIn");
  sel[strlen(sel)-strlen("AtIndex:WithObject:")+1]='\0';
  sel[0]=tolower(sel[0]);
   
  NSString *key=[[NSString alloc] initWithCString:sel];
  [self willChange:NSKeyValueChangeReplacement valuesAtIndexes:[NSIndexSet indexSetWithIndex:index] forKey:key];
  typedef id (*sender)(id obj, SEL selector, int index, id object);
  sender implementation=(sender)[[self superclass] instanceMethodForSelector:_cmd];
  (void)*implementation(self, _cmd, index, object);
  [self didChange:NSKeyValueChangeReplacement valuesAtIndexes:[NSIndexSet indexSetWithIndex:index] forKey:key];
  [key release];
  }
   
   
  -(id)_KVO_className
  {
  return [NSString stringWithCString:isa->name+strlen("KVONotifying_")];
  }
   
  -(Class)_KVO_class
  {
  return isa->super_class;
  }
   
  -(Class)_KVO_classForCoder
  {
  return isa->super_class;
  }
   
   
  +(void)_KVO_buildDependencyUnion
  {
  /*
  This method gathers dependent keys from all superclasses and merges them together
  */
  NSMutableDictionary* observationInfo=[self observationInfo];
  if(!observationInfo)
  {
  [self setObservationInfo:[NSMutableDictionary new]];
  observationInfo=[self observationInfo];
  }
   
  NSMutableDictionary *keyPathsByKey=[NSMutableDictionary dictionary];
   
  id class="self";
  while(class != [NSObject class])
  {
  NSDictionary* classDependents=[(NSDictionary*)[class observationInfo] objectForKey:_KVO_DependentKeysTriggeringChangeNotification];
   
  for(id key in [classDependents allKeys])
  {
  for(id value in [classDependents objectForKey:key])
  {
  NSMutableSet *pathSet=[keyPathsByKey objectForKey:value];
  if(!pathSet)
  {
  pathSet=[NSMutableSet set];
  [keyPathsByKey setObject:pathSet forKey:value];
  }
  [pathSet addObject:key];
  }
  }
   
  class=[class superclass];
  }
  [observationInfo setObject:keyPathsByKey
  forKey:_KVO_KeyPathsForValuesAffectingValueForKey];
  }
   
   
   
  -(void)_KVO_swizzle
  {
  NSString* className=[self className];
  if([className hasPrefix:@"KVONotifying_"])
  return; // this class is already swizzled
  [kvoLock lock];
  isa=[self _KVO_swizzledClass];
  [kvoLock unlock];
  }
   
   
  -(Class)_KVO_swizzledClass
  {
  // find swizzled class
  const char* swizzledName=[[NSString stringWithFormat:@"KVONotifying_%@", [self className]] cString];
  Class swizzledClass = objc_lookUpClass(swizzledName);
   
  if(swizzledClass)
  return swizzledClass;
   
  // swizzled class doesn't exist; create
  swizzledClass = objc_allocateClassPair(isa, swizzledName, 0);
  if(!swizzledClass)
  [NSException raise:@"NSClassCreationException" format:@"couldn't swizzle class %@ for KVO", [self className]];
   
  // add KVO-Observing methods
  int maxMethods=20;
  struct objc_method *newMethods=calloc(sizeof(struct objc_method), maxMethods);
  int currentMethod=0;
   
  {
  // override className so it returns the original class name
  Method className=class_getInstanceMethod([self class], @selector(_KVO_className));
  newMethods[currentMethod].method_name=@selector(className);
  newMethods[currentMethod].method_types=strdup(className->method_types);
  newMethods[currentMethod].method_imp=className->method_imp;
  currentMethod++;
   
  className=class_getInstanceMethod([self class], @selector(_KVO_class));
  newMethods[currentMethod].method_name=@selector(class);
  newMethods[currentMethod].method_types=strdup(className->method_types);
  newMethods[currentMethod].method_imp=className->method_imp;
  currentMethod++;
   
  className=class_getInstanceMethod([self class], @selector(_KVO_classForCoder));
  newMethods[currentMethod].method_name=@selector(classForCoder);
  newMethods[currentMethod].method_types=strdup(className->method_types);
  newMethods[currentMethod].method_imp=className->method_imp;
  currentMethod++;
  }
   
  void *iterator=0;
  Class currentClass=isa;
  struct objc_method_list* list = class_nextMethodList(currentClass, &iterator);
  while(list)
  {
  int i;
  for(i=0; i<list->method_count; i++)
  {
  struct objc_method *method=&list->method_list[i];
  NSString* methodName = NSStringFromSelector(method->method_name);
  SEL kvoSelector=0;
   
  // current method is a setter?
  if(([methodName hasPrefix:@"set"] || [methodName hasPrefix:@"_set"]) &&
  [[self methodSignatureForSelector:method->method_name] numberOfArguments]==3 &&
  [[self class] automaticallyNotifiesObserversForKey:[methodName _KVC_setterKeyNameFromSelectorName]])
  {
  const char* firstParameterType=[[self methodSignatureForSelector:method->method_name] getArgumentTypeAtIndex:2];
  const char* returnType=[[self methodSignatureForSelector:method->method_name] methodReturnType];
   
  char *cleanFirstParameterType=__builtin_alloca(strlen(firstParameterType)+1);
  [self _demangleTypeEncoding:firstParameterType to:cleanFirstParameterType];
   
   
  /* check for correct type: either perfect match
  or primitive signed type matching unsigned type
  (i.e. tolower(@encode(unsigned long)[0])==@encode(long)[0])
  */
  #define CHECK_AND_ASSIGN(a) \
  if(!strcmp(cleanFirstParameterType, @encode(a)) || \
  (strlen(@encode(a))==1 && \
  strlen(cleanFirstParameterType)==1 && \
  tolower(cleanFirstParameterType[0])==@encode(a)[0])) \
  { \
  kvoSelector = @selector( CHANGE_SELECTOR(a) ); \
  }
  // FIX: add more types
  CHECK_AND_ASSIGN(id);
  CHECK_AND_ASSIGN(float);
  CHECK_AND_ASSIGN(double);
  CHECK_AND_ASSIGN(int);
  CHECK_AND_ASSIGN(NSSize);
  CHECK_AND_ASSIGN(NSPoint);
  CHECK_AND_ASSIGN(NSRect);
  CHECK_AND_ASSIGN(NSRange);
  CHECK_AND_ASSIGN(char);
  CHECK_AND_ASSIGN(long);
  CHECK_AND_ASSIGN(SEL);
   
  if(kvoSelector==0 && NSDebugEnabled)
  {
  NSLog(@"type %s not defined in %s:%i (selector %s on class %@)", cleanFirstParameterType, __FILE__, __LINE__, sel_getName(method->method_name), [self className]);
  }
  if(returnType[0]!=_C_VOID)
  {
  if(NSDebugEnabled)
  NSLog(@"selector %s on class %@ has return type %s and will not be modified for automatic KVO notification", sel_getName(method->method_name), [self className], returnType);
  kvoSelector=0;
  }
   
   
  }
   
   
   
  // long selectors
  if(kvoSelector==0)
  {
  id ret=nil;
   
  if([methodName _KVC_setterKeyName:&ret forSelectorNameStartingWith:@"insertObject:in" endingWith:@"AtIndex:"] &&
  ret &&
  [[self methodSignatureForSelector:method->method_name] numberOfArguments] == 4)
  {
  kvoSelector = @selector(KVO_notifying_change_insertObject:inKeyAtIndex:);
  }
  else if([methodName _KVC_setterKeyName:&ret forSelectorNameStartingWith:@"removeObjectFrom" endingWith:@"AtIndex:"] &&
  ret &&
  [[self methodSignatureForSelector:method->method_name] numberOfArguments] == 3)
  {
  kvoSelector = @selector(KVO_notifying_change_removeObjectFromKeyAtIndex:);
  }
  else if([methodName _KVC_setterKeyName:&ret forSelectorNameStartingWith:@"replaceObjectIn" endingWith:@"AtIndex:withObject:"] &&
  ret &&
  [[self methodSignatureForSelector:method->method_name] numberOfArguments] == 4)
  {
  kvoSelector = @selector(KVO_notifying_change_replaceObjectInKeyAtIndex:withObject:);
  }
  else if([methodName _KVC_setterKeyName:&ret forSelectorNameStartingWith:@"remove" endingWith:@"Object:"] &&
  ret &&
  [[self methodSignatureForSelector:method->method_name] numberOfArguments] == 3)
  {
  kvoSelector = @selector(KVO_notifying_change_removeKeyObject:);
  }
  else if([methodName _KVC_setterKeyName:&ret forSelectorNameStartingWith:@"add" endingWith:@"Object:"] &&
  ret &&
  [[self methodSignatureForSelector:method->method_name] numberOfArguments] == 3)
  {
  kvoSelector = @selector(KVO_notifying_change_addKeyObject:);
  }
  }
   
  // these are swizzled so e.g. subclasses of NSMutableDictionary get change notifications in setObject:forKey:
  if([methodName isEqualToString:@"setObject:forKey:"])
  {
  kvoSelector = @selector(KVO_notifying_change_setObject:forKey:);
  }
  if([methodName isEqualToString:@"removeObjectForKey:"])
  {
  kvoSelector = @selector(KVO_notifying_change_removeObjectForKey:forKey:);
  }
   
  // there's a suitable selector for us
  if(kvoSelector!=0)
  {
  // if we already added too many methods, increase the size of the method list array
  if(currentMethod>=maxMethods)
  {
  maxMethods*=2;
  newMethods=realloc(newMethods, maxMethods*sizeof(struct objc_method));
  }
  struct objc_method *newMethod=&newMethods[currentMethod];
   
  // fill in the new method:
  // same name as the method in the superclass
  newMethod->method_name=method->method_name;
  // takes the same types
  newMethod->method_types=strdup(method->method_types);
  // and its implementation is the respective setter
  newMethod->method_imp=[self methodForSelector:kvoSelector];
   
  currentMethod++;
   
  //NSLog(@"replaced method %@ by %@ in class %@", methodName, NSStringFromSelector(newMethod->method_name), [self className]);
  }
  }
  list=class_nextMethodList(currentClass, &iterator);
  if(!list)
  {
  currentClass=currentClass->super_class;
  iterator=0;
  if(currentClass && currentClass->super_class!=currentClass)
  list=class_nextMethodList(currentClass, &iterator);
  }
  }
  #undef CHECK_AND_ASSIGN
   
  // crop the method array to currently used size
  list = calloc(sizeof(struct objc_method_list)+currentMethod*sizeof(struct objc_method), 1);
  list->method_count=currentMethod;
  memcpy(list->method_list, newMethods, sizeof(struct objc_method)*currentMethod);
   
  // add methods
  class_addMethods(swizzledClass, list);
   
  free(newMethods);
   
  objc_registerClassPair(swizzledClass);
   
  // done
  return swizzledClass;
  }
   
  + (BOOL)automaticallyNotifiesObserversForKey:(NSString *)key;
  {
  if([key isEqualToString:@"observationInfo"]) {
  return NO;
  }
   
  return YES;
  }
  @end
   
  #pragma mark -
  #pragma mark Observation info structure
   
   
  @implementation _NSObservationInfo
  - (NSString*)keyPath {
  return [[keyPath retain] autorelease];
  }
   
  - (void)setKeyPath:(NSString*)value {
  if (keyPath != value) {
  [keyPath release];
  keyPath = [value copy];
  }
  }
   
   
   
  - (id)changeDictionary
  {
  return [[changeDictionary retain] autorelease];
  }
   
  - (void)setChangeDictionary:(id)value
  {
  if (changeDictionary != value)
  {
  [changeDictionary release];
  changeDictionary = [value retain];
  }
  }
   
  -(id)observer
  {
  return observer;
  }
   
  -(void)dealloc
  {
  [keyPath release];
  [changeDictionary release];
  [super dealloc];
  }
   
  -(void)observeValueForKeyPath:(NSString*)subKeyPath ofObject:(id)subObject change:(NSDictionary*)changeDict context:(void*)subContext;
  {
  [observer observeValueForKeyPath:keyPath
  ofObject:object
  change:changeDict
  context:context];
  }
   
  -(NSString *)description
  {
  return [NSString stringWithFormat:@"<%@ %p (%@ -> %@)>", [self className], self, keyPath, observer];
  }
  @end

相关文章