//

// AutoCoding.m

//

// Version 2.2.2

//

// Created by Nick Lockwood on 19/11/2011.

// Copyright (c) 2011 Charcoal Design

//

// Distributed under the permissive zlib License

// Get the latest version from here:

//

// https://github.com/nicklockwood/AutoCoding

//

// This software is provided 'as-is', without any express or implied

// warranty. In no event will the authors be held liable for any damages

// arising from the use of this software.

//

// Permission is granted to anyone to use this software for any purpose,

// including commercial applications, and to alter it and redistribute it

// freely, following restrictions:

//

// 1. The origin of this software must not be misrepresented; you must not

// claim that you wrote the original software. If you use this software

// in a product, an acknowledgment in the product documentation would be

// appreciated but is not required.

//

// 2. Altered source versions must be plainly marked as such, and must not be

// misrepresented as being the original software.

//

// 3. This notice may not be removed or altered from any source distribution.

//

#import "AutoCoding.h"

#import <objc/runtime.h>

#pragma clang diagnostic ignored "-Wgnu"

#pragma clang diagnostic ignored "-Wpartial-availability"

#pragma clang diagnostic ignored "-Wobjc-designated-initializers"

static NSString *const AutocodingException = @"AutocodingException";

@implementation NSObject (AutoCoding)

+ (BOOL)supportsSecureCoding

{

return YES;

}

+ (instancetype)objectWithContentsOfFile:(NSString *)filePath

{

//load the file

NSData *data = [NSData dataWithContentsOfFile:filePath];

//attempt to deserialise data as a plist

id object = nil;

if (data)

{

NSPropertyListFormat format;

object = [NSPropertyListSerialization propertyListWithData:data options:NSPropertyListImmutable format:&format error:NULL];

//success?

if (object)

{

//check if object is an NSCoded unarchive

if ([object respondsToSelector:@selector(objectForKeyedSubscript:)] && ((NSDictionary *)object)[@"$archiver"])

{

object = [NSKeyedUnarchiver unarchiveObjectWithData:data];

}

}

else

{

//return raw data

object = data;

}

}

//return object

return object;

}

- (BOOL)writeToFile:(NSString *)filePath atomically:(BOOL)useAuxiliaryFile

{

//note: NSData, NSDictionary and NSArray already implement this method

//and do not save using NSCoding, however the objectWithContentsOfFile

//method will correctly recover these objects anyway

//archive object

NSData *data = [NSKeyedArchiver archivedDataWithRootObject:self];

return [data writeToFile:filePath atomically:useAuxiliaryFile];

}

+ (NSDictionary<NSString *, Class> *)codableProperties

{

//deprecated

SEL deprecatedSelector = NSSelectorFromString(@"uncodableProperties");

NSArray *uncodableProperties = nil;

if ([self respondsToSelector:deprecatedSelector] || [self instancesRespondToSelector:deprecatedSelector])

{

uncodableProperties = [self valueForKey:@"uncodableProperties"];

NSLog(@"AutoCoding Warning: uncodableProperties method is no longer supported. Use ivars, or synthesize your properties using non-KVC-compliant names to avoid coding them instead.");

}

unsigned int propertyCount;

__autoreleasing NSMutableDictionary *codableProperties = [NSMutableDictionary dictionary];

objc_property_t *properties = class_copyPropertyList(self, &propertyCount);

for (unsigned int i = 0; i < propertyCount; i++)

{

//get property name

objc_property_t property = properties[i];

const char *propertyName = property_getName(property);

__autoreleasing NSString *key = @(propertyName);

//check if codable

if (![uncodableProperties containsObject:key])

{

//get property type

Class propertyClass = nil;

char *typeEncoding = property_copyAttributeValue(property, "T");

switch (typeEncoding[0])

{

case '@':

{

if (strlen(typeEncoding) >= 3)

{

char *className = strndup(typeEncoding + 2, strlen(typeEncoding) - 3);

__autoreleasing NSString *name = @(className);

NSRange range = [name rangeOfString:@"<"];

if (range.location != NSNotFound)

{

name = [name substringToIndex:range.location];

}

propertyClass = NSClassFromString(name) ?: [NSObject class];

free(className);

}

break;

}

case 'c':

case 'i':

case 's':

case 'l':

case 'q':

case 'C':

case 'I':

case 'S':

case 'L':

case 'Q':

case 'f':

case 'd':

case 'B':

{

propertyClass = [NSNumber class];

break;

}

case '{':

{

propertyClass = [NSValue class];

break;

}

}

free(typeEncoding);

if (propertyClass)

{

//check if there is a backing ivar

char *ivar = property_copyAttributeValue(property, "V");

if (ivar)

{

//check if ivar has KVC-compliant name

__autoreleasing NSString *ivarName = @(ivar);

if ([ivarName isEqualToString:key] || [ivarName isEqualToString:[@"_" stringByAppendingString:key]])

{

//no setter, but setValue:forKey: will still work

codableProperties[key] = propertyClass;

}

free(ivar);

}

else

{

//check if property is dynamic and readwrite

char *dynamic = property_copyAttributeValue(property, "D");

char *readonly = property_copyAttributeValue(property, "R");

if (dynamic && !readonly)

{

//no ivar, but setValue:forKey: will still work

codableProperties[key] = propertyClass;

}

free(dynamic);

free(readonly);

}

}

}

}

free(properties);

return codableProperties;

}

- (NSDictionary<NSString *, Class> *)codableProperties

{

__autoreleasing NSDictionary *codableProperties = objc_getAssociatedObject([self class], _cmd);

if (!codableProperties)

{

codableProperties = [NSMutableDictionary dictionary];

Class subclass = [self class];

while (subclass != [NSObject class])

{

[(NSMutableDictionary *)codableProperties addEntriesFromDictionary:[subclass codableProperties]];

subclass = [subclass superclass];

}

codableProperties = [NSDictionary dictionaryWithDictionary:codableProperties];

//make the association atomically so that we don't need to bother with an @synchronize

objc_setAssociatedObject([self class], _cmd, codableProperties, OBJC_ASSOCIATION_RETAIN);

}

return codableProperties;

}

- (NSDictionary<NSString *, id> *)dictionaryRepresentation

{

NSMutableDictionary *dict = [NSMutableDictionary dictionary];

for (__unsafe_unretained NSString *key in self.codableProperties)

{

id value = [self valueForKey:key];

if (value) dict[key] = value;

}

return dict;

}

- (void)setWithCoder:(NSCoder *)aDecoder

{

BOOL secureAvailable = [aDecoder respondsToSelector:@selector(decodeObjectOfClass:forKey:)];

BOOL secureSupported = [[self class] supportsSecureCoding];

NSDictionary *properties = self.codableProperties;

for (NSString *key in properties)

{

id object = nil;

Class propertyClass = properties[key];

if (secureAvailable)

{

object = [aDecoder decodeObjectOfClass:propertyClass forKey:key];

}

else

{

object = [aDecoder decodeObjectForKey:key];

}

if (object)

{

if (secureSupported && ![object isKindOfClass:propertyClass] && object != [NSNull null])

{

[NSException raise:AutocodingException format:@"Expected '%@' to be a %@, but was actually a %@", key, propertyClass, [object class]];

}

[self setValue:object forKey:key];

}

}

}

- (instancetype)initWithCoder:(NSCoder *)aDecoder

{

[self setWithCoder:aDecoder];

return self;

}

- (void)encodeWithCoder:(NSCoder *)aCoder

{

for (NSString *key in self.codableProperties)

{

id object = [self valueForKey:key];

if (object) [aCoder encodeObject:object forKey:key];

}

}

@end