ray
/
zuoyebang
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
7 Commits
1 Branch
0 Tags
480 MiB
 
 
 
 
Tree: 2449c0a719
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '2449c0a719'
${ noResults }
zuoyebang/tongxin/ThirdPartyLib/YYKit/Base/Foundation/NSObject+YYAdd.m

396 lines
14 KiB
Raw Blame History

//
// NSObject+YYAdd.m
// YYKit <https://github.com/ibireme/YYKit>
//
// Created by ibireme on 14/10/8.
// Copyright (c) 2015 ibireme.
//
// This source code is licensed under the MIT-style license found in the
// LICENSE file in the root directory of this source tree.
//
#import "NSObject+YYAdd.h"
#import "YYKitMacro.h"
#import <objc/objc.h>
#import <objc/runtime.h>
YYSYNTH_DUMMY_CLASS(NSObject_YYAdd)
@implementation NSObject (YYAdd)
/*
NSInvocation is much slower than objc_msgSend()...
Do not use it if you have performance issues.
*/
#define INIT_INV(_last_arg_, _return_) \
NSMethodSignature * sig = [self methodSignatureForSelector:sel]; \
if (!sig) { [self doesNotRecognizeSelector:sel]; return _return_; } \
NSInvocation *inv = [NSInvocation invocationWithMethodSignature:sig]; \
if (!inv) { [self doesNotRecognizeSelector:sel]; return _return_; } \
[inv setTarget:self]; \
[inv setSelector:sel]; \
va_list args; \
va_start(args, _last_arg_); \
[NSObject setInv:inv withSig:sig andArgs:args]; \
va_end(args);
- (id)performSelectorWithArgs:(SEL)sel, ...{
INIT_INV(sel, nil);
[inv invoke];
return [NSObject getReturnFromInv:inv withSig:sig];
}
- (void)performSelectorWithArgs:(SEL)sel afterDelay:(NSTimeInterval)delay, ...{
INIT_INV(delay, );
[inv retainArguments];
[inv performSelector:@selector(invoke) withObject:nil afterDelay:delay];
}
- (id)performSelectorWithArgsOnMainThread:(SEL)sel waitUntilDone:(BOOL)wait, ...{
INIT_INV(wait, nil);
if (!wait) [inv retainArguments];
[inv performSelectorOnMainThread:@selector(invoke) withObject:nil waitUntilDone:wait];
return wait ? [NSObject getReturnFromInv:inv withSig:sig] : nil;
}
- (id)performSelectorWithArgs:(SEL)sel onThread:(NSThread *)thr waitUntilDone:(BOOL)wait, ...{
INIT_INV(wait, nil);
if (!wait) [inv retainArguments];
[inv performSelector:@selector(invoke) onThread:thr withObject:nil waitUntilDone:wait];
return wait ? [NSObject getReturnFromInv:inv withSig:sig] : nil;
}
- (void)performSelectorWithArgsInBackground:(SEL)sel, ...{
INIT_INV(sel, );
[inv retainArguments];
[inv performSelectorInBackground:@selector(invoke) withObject:nil];
}
#undef INIT_INV
+ (id)getReturnFromInv:(NSInvocation *)inv withSig:(NSMethodSignature *)sig {
NSUInteger length = [sig methodReturnLength];
if (length == 0) return nil;
char *type = (char *)[sig methodReturnType];
while (*type == 'r' || // const
*type == 'n' || // in
*type == 'N' || // inout
*type == 'o' || // out
*type == 'O' || // bycopy
*type == 'R' || // byref
*type == 'V') { // oneway
type++; // cutoff useless prefix
}
#define return_with_number(_type_) \
do { \
_type_ ret; \
[inv getReturnValue:&ret]; \
return @(ret); \
} while (0)
switch (*type) {
case 'v': return nil; // void
case 'B': return_with_number(bool);
case 'c': return_with_number(char);
case 'C': return_with_number(unsigned char);
case 's': return_with_number(short);
case 'S': return_with_number(unsigned short);
case 'i': return_with_number(int);
case 'I': return_with_number(unsigned int);
case 'l': return_with_number(int);
case 'L': return_with_number(unsigned int);
case 'q': return_with_number(long long);
case 'Q': return_with_number(unsigned long long);
case 'f': return_with_number(float);
case 'd': return_with_number(double);
case 'D': { // long double
long double ret;
[inv getReturnValue:&ret];
return [NSNumber numberWithDouble:ret];
};
case '@': { // id
id ret = nil;
[inv getReturnValue:&ret];
return ret;
};
case '#': { // Class
Class ret = nil;
[inv getReturnValue:&ret];
return ret;
};
default: { // struct / union / SEL / void* / unknown
const char *objCType = [sig methodReturnType];
char *buf = calloc(1, length);
if (!buf) return nil;
[inv getReturnValue:buf];
NSValue *value = [NSValue valueWithBytes:buf objCType:objCType];
free(buf);
return value;
};
}
#undef return_with_number
}
+ (void)setInv:(NSInvocation *)inv withSig:(NSMethodSignature *)sig andArgs:(va_list)args {
NSUInteger count = [sig numberOfArguments];
for (int index = 2; index < count; index++) {
char *type = (char *)[sig getArgumentTypeAtIndex:index];
while (*type == 'r' || // const
*type == 'n' || // in
*type == 'N' || // inout
*type == 'o' || // out
*type == 'O' || // bycopy
*type == 'R' || // byref
*type == 'V') { // oneway
type++; // cutoff useless prefix
}
BOOL unsupportedType = NO;
switch (*type) {
case 'v': // 1: void
case 'B': // 1: bool
case 'c': // 1: char / BOOL
case 'C': // 1: unsigned char
case 's': // 2: short
case 'S': // 2: unsigned short
case 'i': // 4: int / NSInteger(32bit)
case 'I': // 4: unsigned int / NSUInteger(32bit)
case 'l': // 4: long(32bit)
case 'L': // 4: unsigned long(32bit)
{ // 'char' and 'short' will be promoted to 'int'.
int arg = va_arg(args, int);
[inv setArgument:&arg atIndex:index];
} break;
case 'q': // 8: long long / long(64bit) / NSInteger(64bit)
case 'Q': // 8: unsigned long long / unsigned long(64bit) / NSUInteger(64bit)
{
long long arg = va_arg(args, long long);
[inv setArgument:&arg atIndex:index];
} break;
case 'f': // 4: float / CGFloat(32bit)
{ // 'float' will be promoted to 'double'.
double arg = va_arg(args, double);
float argf = arg;
[inv setArgument:&argf atIndex:index];
} break;
case 'd': // 8: double / CGFloat(64bit)
{
double arg = va_arg(args, double);
[inv setArgument:&arg atIndex:index];
} break;
case 'D': // 16: long double
{
long double arg = va_arg(args, long double);
[inv setArgument:&arg atIndex:index];
} break;
case '*': // char *
case '^': // pointer
{
void *arg = va_arg(args, void *);
[inv setArgument:&arg atIndex:index];
} break;
case ':': // SEL
{
SEL arg = va_arg(args, SEL);
[inv setArgument:&arg atIndex:index];
} break;
case '#': // Class
{
Class arg = va_arg(args, Class);
[inv setArgument:&arg atIndex:index];
} break;
case '@': // id
{
id arg = va_arg(args, id);
[inv setArgument:&arg atIndex:index];
} break;
case '{': // struct
{
if (strcmp(type, @encode(CGPoint)) == 0) {
CGPoint arg = va_arg(args, CGPoint);
[inv setArgument:&arg atIndex:index];
} else if (strcmp(type, @encode(CGSize)) == 0) {
CGSize arg = va_arg(args, CGSize);
[inv setArgument:&arg atIndex:index];
} else if (strcmp(type, @encode(CGRect)) == 0) {
CGRect arg = va_arg(args, CGRect);
[inv setArgument:&arg atIndex:index];
} else if (strcmp(type, @encode(CGVector)) == 0) {
CGVector arg = va_arg(args, CGVector);
[inv setArgument:&arg atIndex:index];
} else if (strcmp(type, @encode(CGAffineTransform)) == 0) {
CGAffineTransform arg = va_arg(args, CGAffineTransform);
[inv setArgument:&arg atIndex:index];
} else if (strcmp(type, @encode(CATransform3D)) == 0) {
CATransform3D arg = va_arg(args, CATransform3D);
[inv setArgument:&arg atIndex:index];
} else if (strcmp(type, @encode(NSRange)) == 0) {
NSRange arg = va_arg(args, NSRange);
[inv setArgument:&arg atIndex:index];
} else if (strcmp(type, @encode(UIOffset)) == 0) {
UIOffset arg = va_arg(args, UIOffset);
[inv setArgument:&arg atIndex:index];
} else if (strcmp(type, @encode(UIEdgeInsets)) == 0) {
UIEdgeInsets arg = va_arg(args, UIEdgeInsets);
[inv setArgument:&arg atIndex:index];
} else {
unsupportedType = YES;
}
} break;
case '(': // union
{
unsupportedType = YES;
} break;
case '[': // array
{
unsupportedType = YES;
} break;
default: // what?!
{
unsupportedType = YES;
} break;
}
if (unsupportedType) {
// Try with some dummy type...
NSUInteger size = 0;
NSGetSizeAndAlignment(type, &size, NULL);
#define case_size(_size_) \
else if (size <= 4 * _size_ ) { \
struct dummy { char tmp[4 * _size_]; }; \
struct dummy arg = va_arg(args, struct dummy); \
[inv setArgument:&arg atIndex:index]; \
}
if (size == 0) { }
case_size( 1) case_size( 2) case_size( 3) case_size( 4)
case_size( 5) case_size( 6) case_size( 7) case_size( 8)
case_size( 9) case_size(10) case_size(11) case_size(12)
case_size(13) case_size(14) case_size(15) case_size(16)
case_size(17) case_size(18) case_size(19) case_size(20)
case_size(21) case_size(22) case_size(23) case_size(24)
case_size(25) case_size(26) case_size(27) case_size(28)
case_size(29) case_size(30) case_size(31) case_size(32)
case_size(33) case_size(34) case_size(35) case_size(36)
case_size(37) case_size(38) case_size(39) case_size(40)
case_size(41) case_size(42) case_size(43) case_size(44)
case_size(45) case_size(46) case_size(47) case_size(48)
case_size(49) case_size(50) case_size(51) case_size(52)
case_size(53) case_size(54) case_size(55) case_size(56)
case_size(57) case_size(58) case_size(59) case_size(60)
case_size(61) case_size(62) case_size(63) case_size(64)
else {
/*
Larger than 256 byte?! I don't want to deal with this stuff up...
Ignore this argument.
*/
struct dummy {char tmp;};
for (int i = 0; i < size; i++) va_arg(args, struct dummy);
NSLog(@"YYKit performSelectorWithArgs unsupported type:%s (%lu bytes)",
[sig getArgumentTypeAtIndex:index],(unsigned long)size);
}
#undef case_size
}
}
}
- (void)performSelector:(SEL)sel afterDelay:(NSTimeInterval)delay {
[self performSelector:sel withObject:nil afterDelay:delay];
}
+ (BOOL)swizzleInstanceMethod:(SEL)originalSel with:(SEL)newSel {
Method originalMethod = class_getInstanceMethod(self, originalSel);
Method newMethod = class_getInstanceMethod(self, newSel);
if (!originalMethod || !newMethod) return NO;
class_addMethod(self,
originalSel,
class_getMethodImplementation(self, originalSel),
method_getTypeEncoding(originalMethod));
class_addMethod(self,
newSel,
class_getMethodImplementation(self, newSel),
method_getTypeEncoding(newMethod));
method_exchangeImplementations(class_getInstanceMethod(self, originalSel),
class_getInstanceMethod(self, newSel));
return YES;
}
+ (BOOL)swizzleClassMethod:(SEL)originalSel with:(SEL)newSel {
Class class = object_getClass(self);
Method originalMethod = class_getInstanceMethod(class, originalSel);
Method newMethod = class_getInstanceMethod(class, newSel);
if (!originalMethod || !newMethod) return NO;
method_exchangeImplementations(originalMethod, newMethod);
return YES;
}
- (void)setAssociateValue:(id)value withKey:(void *)key {
objc_setAssociatedObject(self, key, value, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}
- (void)setAssociateWeakValue:(id)value withKey:(void *)key {
objc_setAssociatedObject(self, key, value, OBJC_ASSOCIATION_ASSIGN);
}
- (void)removeAssociatedValues {
objc_removeAssociatedObjects(self);
}
- (id)getAssociatedValueForKey:(void *)key {
return objc_getAssociatedObject(self, key);
}
+ (NSString *)className {
return NSStringFromClass(self);
}
- (NSString *)className {
return [NSString stringWithUTF8String:class_getName([self class])];
}
- (id)deepCopy {
id obj = nil;
@try {
obj = [NSKeyedUnarchiver unarchiveObjectWithData:[NSKeyedArchiver archivedDataWithRootObject:self]];
}
@catch (NSException *exception) {
NSLog(@"%@", exception);
}
return obj;
}
- (id)deepCopyWithArchiver:(Class)archiver unarchiver:(Class)unarchiver {
id obj = nil;
@try {
obj = [unarchiver unarchiveObjectWithData:[archiver archivedDataWithRootObject:self]];
}
@catch (NSException *exception) {
NSLog(@"%@", exception);
}
return obj;
}
@end