//
// EVReflection.swift
//
// Created by Edwin Vermeer on 28-09-14.
// Copyright (c) 2014 EVICT BV. All rights reserved.
//
import Foundation
/**
Reflection methods
*/
final public class EVReflection {
// MARK: - From and to Dictrionary parsing
/**
Create an object from a dictionary
- parameter dictionary: The dictionary that will be converted to an object
- parameter anyobjectTypeString: The string representation of the object type that will be created
- parameter conversionOptions: Option set for the various conversion options.
- returns: The object that is created from the dictionary
*/
public class func fromDictionary(_ dictionary: NSDictionary, anyobjectTypeString: String, conversionOptions: ConversionOptions = .DefaultDeserialize) -> NSObject? {
if var nsobject = swiftClassFromString(anyobjectTypeString) {
if let evResult = nsobject as? EVReflectable {
if let type = evResult.getType(dictionary) as? NSObject {
nsobject = type
}
if let specific = evResult.getSpecificType(dictionary) as? NSObject {
nsobject = specific
} else if let evResult = nsobject as? EVGenericsKVC {
nsobject = evResult.getGenericType()
}
}
nsobject = setPropertiesfromDictionary(dictionary, anyObject: nsobject, conversionOptions: conversionOptions)
return nsobject
}
return nil
}
/**
Set object properties from a dictionary
- parameter dictionary: The dictionary that will be converted to an object
- parameter anyObject: The object where the properties will be set
- parameter conversionOptions: Option set for the various conversion options.
- returns: The object that is created from the dictionary
*/
@discardableResult
public class func setPropertiesfromDictionary<T>(_ dictionary: NSDictionary, anyObject: T, conversionOptions: ConversionOptions = .DefaultDeserialize, forKeyPath: String? = nil) -> T where T: NSObject {
guard let dict = ((forKeyPath == nil) ? dictionary : dictionary.value(forKeyPath: forKeyPath!) as? NSDictionary) else {
evPrint(.UnknownKeypath, "ERROR: The forKeyPath '\(forKeyPath ?? "")' did not return a dictionary")
return anyObject
}
(anyObject as? EVReflectable)?.initValidation(dict)
let (keyMapping, _, types) = getKeyMapping(anyObject, dictionary: dict, conversionOptions: .None)
for (k, v) in dict {
let keyInObject: String? = (keyMapping.first { $0.keyInResource == k as? String })?.keyInObject
if keyInObject != nil {
let original: Any? = getValue(anyObject, key: keyInObject!)
let dictKey: String = cleanupKey(anyObject, key: k as? String ?? "", tryMatch: types) ?? ""
let valid : Bool
let dictValue : Any?
if conversionOptions.contains(.PropertyConverter) && (anyObject as? EVReflectable)?.propertyConverters().filter({$0.key == keyInObject}).first != nil {
valid = false
dictValue = nil
} else {
(dictValue, valid) = dictionaryAndArrayConversion(anyObject, key: keyInObject!, fieldType: types[dictKey] as? String ?? types[keyInObject!] as? String, original: original, theDictValue: v as Any?, conversionOptions: conversionOptions)
}
if var value: Any = valid ? dictValue : (v as Any) {
if let type: String = types[k as! String] as? String {
let t: AnyClass? = swiftClassTypeFromString(type)
if let c = t as? EVCustomReflectable.Type {
if let v = c.constructWith(value: value) {
value = v
}
}
}
setObjectValue(anyObject, key: keyInObject!, theValue: value, typeInObject: types[keyInObject!] as? String, valid: valid, conversionOptions: conversionOptions)
}
}
}
return anyObject
}
public class func getValue(_ fromObject: NSObject, key: String) -> Any? {
return (Mirror(reflecting: fromObject).children.filter({$0.0 == key}).first)?.value
}
/**
Based on an object and a dictionary create a keymapping plus a dictionary of properties plus a dictionary of types
- parameter anyObject: the object for the mapping
- parameter dictionary: the dictionary that has to be mapped
- parameter conversionOptions: Option set for the various conversion options.
- returns: The mapping, keys and values of all properties to items in a dictionary
*/
fileprivate static func getKeyMapping<T>(_ anyObject: T, dictionary: NSDictionary, conversionOptions: ConversionOptions = .DefaultDeserialize) -> (keyMapping: [(keyInObject: String?, keyInResource: String?)], properties: NSDictionary, types: NSDictionary) where T: NSObject {
let (properties, types) = toDictionary(anyObject, conversionOptions: conversionOptions, isCachable: true)
var keyMapping: [(keyInObject: String?, keyInResource: String?)] = []
if let reflectable = anyObject as? EVReflectable {
keyMapping = reflectable.propertyMapping()
}
// Add the mapping from the keys in the object.
for (objectKey, _) in properties {
if (keyMapping.first { $0.keyInObject == objectKey as? String }) == nil {
if let dictKey = cleanupKey(anyObject, key: objectKey as? String ?? "", tryMatch: dictionary) {
keyMapping.append((objectKey as? String, dictKey))
} else {
keyMapping.append((objectKey as? String, objectKey as? String))
}
}
}
// Also add the unknown mapping, these have to be handled in setValue forUndefinedKey
for item in dictionary {
var isAdded = false
if (keyMapping.first { $0.keyInResource == (item.key as? String ?? "") }) == nil {
if let reflectable = anyObject as? EVReflectable {
if let mapping = reflectable.propertyMapping().filter({$0.keyInResource == item.key as? String}).first {
keyMapping.append(mapping)
isAdded = true
}
}
if !isAdded {
keyMapping.append((item.key as? String, item.key as? String))
}
}
}
return (keyMapping, properties, types)
}
fileprivate static let properiesCache = NSCache<NSString, NSDictionary>()
fileprivate static let typesCache = NSCache<NSString, NSDictionary>()
/**
Convert an object to a dictionary while cleaning up the keys
- parameter theObject: The object that will be converted to a dictionary
- parameter conversionOptions: Option set for the various conversion options.
- returns: The dictionary that is created from theObject plus a dictionary of propery types.
*/
public class func toDictionary(_ theObject: NSObject, conversionOptions: ConversionOptions = .DefaultSerialize, isCachable: Bool = false, parents: [NSObject] = []) -> (NSDictionary, NSDictionary) {
var pdict: NSDictionary?
var tdict: NSDictionary?
var i = 1
for parent in parents {
if parent === theObject {
pdict = NSMutableDictionary()
pdict!.setValue("\(i)", forKey: "_EVReflection_parent_")
tdict = NSMutableDictionary()
tdict!.setValue("NSString", forKey: "_EVReflection_parent_")
return (pdict!, tdict!)
}
i = i + 1
}
var theParents = parents
theParents.append(theObject)
var p: NSDictionary = NSDictionary()
var t: NSDictionary = NSDictionary()
let key: NSString = "\(swiftStringFromClass(theObject)).\(conversionOptions.rawValue)" as NSString
if isCachable, let cachedVersionProperty = properiesCache.object(forKey: key), let cachedVersionTypes = typesCache.object(forKey: key) {
p = cachedVersionProperty
t = cachedVersionTypes
} else {
let reflected = Mirror(reflecting: theObject)
var (properties, types) = reflectedSub(theObject, reflected: reflected, conversionOptions: conversionOptions, isCachable: isCachable, parents: theParents)
if conversionOptions.contains(.KeyCleanup) {
(properties, types) = cleanupKeysAndValues(theObject, properties:properties, types:types)
}
p = properties
t = types
if isCachable {
properiesCache.setObject(p, forKey: key)
typesCache.setObject(t, forKey: key)
}
}
return (p, t)
}
// MARK: - From and to JSON parsing
/**
Return a dictionary representation for the json string
- parameter json: The json string that will be converted
- returns: The dictionary representation of the json
*/
public class func dictionaryFromJson(_ json: String?) -> NSDictionary {
let result = NSMutableDictionary()
if json == nil {
evPrint(.IsInvalidJson, "ERROR: nil is not valid json!")
} else if let jsonData = json!.data(using: String.Encoding.utf8) {
do {
if let jsonDic = try JSONSerialization.jsonObject(with: jsonData, options: JSONSerialization.ReadingOptions.mutableContainers) as? NSDictionary {
return jsonDic
}
} catch {
evPrint(.IsInvalidJson, "ERROR: Invalid json! \(error.localizedDescription)")
}
}
return result
}
/**
Return an array of dictionaries as the representation for the json string
- parameter json: The json string that will be converted
- returns: The dictionary representation of the json
*/
public class func dictionaryArrayFromJson(_ json: String?) -> [NSDictionary] {
let result = [NSDictionary]()
if json == nil {
evPrint(.IsInvalidJson, "ERROR: nil is not valid json!")
} else if let jsonData = json!.data(using: String.Encoding.utf8) {
do {
if let jsonDic = try JSONSerialization.jsonObject(with: jsonData, options: JSONSerialization.ReadingOptions.mutableContainers) as? [NSDictionary] {
return jsonDic
}
} catch {
evPrint(.IsInvalidJson, "ERROR: Invalid json! \(error.localizedDescription)")
}
}
return result
}
/**
Return an array representation for the json string
- parameter type: An instance of the type where the array will be created of.
- parameter json: The json string that will be converted
- parameter conversionOptions: Option set for the various conversion options.
- returns: The array of dictionaries representation of the json
*/
public class func arrayFromData<T>(_ theObject: NSObject? = nil, type: T, data: Data?, conversionOptions: ConversionOptions = .DefaultDeserialize, forKeyPath: String? = nil) -> [T] {
var result = [T]()
if data == nil {
evPrint(.IsInvalidJson, "ERROR: json data is nil!")
return result
}
do {
var serialized = try JSONSerialization.jsonObject(with: data!, options: JSONSerialization.ReadingOptions.mutableContainers)
if serialized is NSDictionary {
if forKeyPath == nil {
evPrint(.IsInvalidJson, "ERROR: The root of the json is an object and not an array. Specify a forKeyPath to get an item as an array")
return result
} else {
serialized = (serialized as! NSDictionary).value(forKeyPath: forKeyPath!) as? [NSDictionary] ?? []
}
}
if let jsonDic: [Dictionary<String, AnyObject>] = serialized as? [Dictionary<String, AnyObject>] {
let nsobjectype: NSObject.Type? = T.self as? NSObject.Type
if nsobjectype == nil {
evPrint(.ShouldExtendNSObject, "ERROR: EVReflection can only be used with types with NSObject as it's minimal base type")
return result
}
result = jsonDic.map({
let nsobject: NSObject = nsobjectype!.init()
return (setPropertiesfromDictionary($0 as NSDictionary, anyObject: nsobject, conversionOptions: conversionOptions) as? T)!
})
}
} catch {
evPrint(.IsInvalidJson, "ERROR: Invalid json! \(error.localizedDescription)")
}
return result
}
/**
Return an array representation for the json string
- parameter type: An instance of the type where the array will be created of.
- parameter json: The json string that will be converted
- parameter conversionOptions: Option set for the various conversion options.
- returns: The array of dictionaries representation of the json
*/
public class func arrayFromJson<T>(type: T, json: String?, conversionOptions: ConversionOptions = .DefaultDeserialize, forKeyPath: String? = nil) -> [T] {
let result = [T]()
if json == nil {
evPrint(.IsInvalidJson, "ERROR: nil is not valid json!")
return result
}
guard let data = json!.data(using: String.Encoding.utf8) else {
evPrint(.IsInvalidJson, "ERROR: Could not get Data from json string using utf8 encoding")
return result
}
return arrayFromData(type: type, data: data, conversionOptions: conversionOptions, forKeyPath: forKeyPath)
}
/**
Return a Json string representation of this object
- parameter theObject: The object that will be loged
- parameter conversionOptions: Option set for the various conversion options.
- returns: The string representation of the object
*/
public class func toJsonString(_ theObject: NSObject, conversionOptions: ConversionOptions = .DefaultSerialize, prettyPrinted: Bool = false) -> String {
let data = toJsonData(theObject, conversionOptions: conversionOptions, prettyPrinted: prettyPrinted)
return String(data: data, encoding: .utf8) ?? ""
}
/**
Return a Json Data representation of this object
- parameter theObject: The object that will be loged
- parameter conversionOptions: Option set for the various conversion options.
- returns: The Data representation of the object
*/
public class func toJsonData(_ theObject: NSObject, conversionOptions: ConversionOptions = .DefaultSerialize, prettyPrinted: Bool = false) -> Data {
var dict: NSDictionary
// Custom or standard toDictionary
if let v = theObject as? EVCustomReflectable {
dict = v.toCodableValue() as? NSDictionary ?? NSDictionary()
} else {
let (dictionary, _) = EVReflection.toDictionary(theObject, conversionOptions: conversionOptions)
dict = dictionary
}
dict = convertDictionaryForJsonSerialization(dict, theObject: theObject)
do {
if prettyPrinted {
return try JSONSerialization.data(withJSONObject: dict, options: .prettyPrinted)
}
return try JSONSerialization.data(withJSONObject: dict, options: [])
} catch { }
return Data()
}
// MARK: - Adding functionality to objects
/**
Dump the content of this object to the output
- parameter theObject: The object that will be loged
*/
public class func logObject(_ theObject: EVReflectable, prettyPrinted: Bool = true) {
NSLog(description(theObject, prettyPrinted: prettyPrinted))
}
/**
Return a string representation of this object
- parameter theObject: The object that will be loged
- parameter conversionOptions: Option set for the various conversion options.
- returns: The string representation of the object
*/
public class func description(_ theObject: EVReflectable, conversionOptions: ConversionOptions = .DefaultSerialize, prettyPrinted: Bool = true) -> String {
if let obj = theObject as? NSObject {
return "\(swiftStringFromClass(obj)) = \(theObject.toJsonString(prettyPrinted: prettyPrinted))"
}
evPrint(.ShouldExtendNSObject, "ERROR: \(String(reflecting: theObject)) should have NSObject as it's base type.")
return "\(String(reflecting: theObject))"
}
/**
Create a hashvalue for the object
- parameter theObject: The object for what you want a hashvalue
- returns: the hashvalue for the object
*/
public class func hashValue(_ theObject: NSObject) -> Int {
let (hasKeys, _) = toDictionary(theObject, conversionOptions: .DefaultComparing)
return Int(hasKeys.map {$1}.reduce(0) {(31 &* $0) &+ ($1 as AnyObject).hash})
}
/**
Encode any object
- parameter theObject: The object that we want to encode.
- parameter aCoder: The NSCoder that will be used for encoding the object.
- parameter conversionOptions: Option set for the various conversion options.
*/
public class func encodeWithCoder(_ theObject: NSObject, aCoder: NSCoder, conversionOptions: ConversionOptions = .DefaultNSCoding) {
let (hasKeys, _) = toDictionary(theObject, conversionOptions: conversionOptions)
for (key, value) in hasKeys {
aCoder.encode(value, forKey: key as? String ?? "")
}
}
/**
Decode any object
- parameter theObject: The object that we want to decode.
- parameter aDecoder: The NSCoder that will be used for decoding the object.
- parameter conversionOptions: Option set for the various conversion options.
*/
public class func decodeObjectWithCoder(_ theObject: NSObject, aDecoder: NSCoder, conversionOptions: ConversionOptions = .DefaultNSCoding) {
let (hasKeys, _) = toDictionary(theObject, conversionOptions: conversionOptions, isCachable: true)
let dict = NSMutableDictionary()
for (key, _) in hasKeys {
if aDecoder.containsValue(forKey: (key as? String)!) {
let newValue: AnyObject? = aDecoder.decodeObject(forKey: (key as? String)!) as AnyObject?
if !(newValue is NSNull) {
dict[(key as? String)!] = newValue
}
}
}
EVReflection.setPropertiesfromDictionary(dict, anyObject: theObject, conversionOptions: conversionOptions)
}
/**
Compare all fields of 2 objects
- parameter lhs: The first object for the comparisson
- parameter rhs: The second object for the comparisson
- returns: true if the objects are the same, otherwise false
*/
public class func areEqual(_ lhs: NSObject, rhs: NSObject) -> Bool {
if swiftStringFromClass(lhs) != swiftStringFromClass(rhs) {
return false
}
let (lhsdict, _) = toDictionary(lhs, conversionOptions: .DefaultComparing)
let (rhsdict, _) = toDictionary(rhs, conversionOptions: .DefaultComparing)
return dictionariesAreEqual(lhsdict, rhsdict: rhsdict)
}
/**
Compare 2 dictionaries
- parameter lhsdict: Compare this dictionary
- parameter rhsdict: Compare with this dictionary
- returns: Are the dictionaries equal or not
*/
public class func dictionariesAreEqual(_ lhsdict: NSDictionary, rhsdict: NSDictionary) -> Bool {
for (key, value) in rhsdict {
if let compareTo = lhsdict[(key as? String)!] {
if let dateCompareTo = compareTo as? Date, let dateValue = value as? Date {
let t1 = Int64(dateCompareTo.timeIntervalSince1970)
let t2 = Int64(dateValue.timeIntervalSince1970)
if t1 != t2 {
return false
}
} else if let array = compareTo as? NSArray, let arr = value as? NSArray {
if arr.count != array.count {
return false
}
for (index, arrayValue) in array.enumerated() {
if arrayValue as? NSDictionary != nil {
if !dictionariesAreEqual((arrayValue as? NSDictionary)!, rhsdict: (arr[index] as? NSDictionary)!) {
return false
}
} else {
if !(arrayValue as AnyObject).isEqual(arr[index]) {
return false
}
}
}
} else if !(compareTo as AnyObject).isEqual(value) {
return false
}
}
}
return true
}
// MARK: - Reflection helper functions
/**
Get the app name from the 'Bundle name' and if that's empty, then from the 'Bundle identifier' otherwise we assume it's a EVReflection unit test and use that bundle identifier
- parameter forObject: Pass an object to this method if you know a class from the bundele where you want the name for.
- returns: A cleaned up name of the app.
*/
public class func getCleanAppName(_ forObject: NSObject? = nil) -> String {
// if an object was specified, then always use the bundle name of that class
if forObject != nil {
return nameForBundle(Bundle(for: type(of: forObject!)))
}
// If no object was specified but an identifier was set, then use that identifier.
if EVReflection.bundleIdentifier != nil {
return EVReflection.bundleIdentifier!
}
// use the bundle name from the main bundle, if that's not set use the identifier
return nameForBundle(Bundle.main)
}
/**
Get the app name from the 'Bundle name' and if that's empty, then from the 'Bundle identifier' otherwise we assume it's a EVReflection unit test and use that bundle identifier
- parameter aClass: Pass an AnyClass to this method if you know a class from the bundele where you want the name for.
- returns: A cleaned up name of the app.
*/
public class func getCleanAppName(_ aClass: AnyClass?) -> String {
// if an object was specified, then always use the bundle name of that class
if aClass != nil {
return nameForBundle(Bundle(for: aClass!))
}
// If no object was specified but an identifier was set, then use that identifier.
if EVReflection.bundleIdentifier != nil {
return EVReflection.bundleIdentifier!
}
// use the bundle name from the main bundle, if that's not set use the identifier
return nameForBundle(Bundle.main)
}
/// Variable that can be set using setBundleIdentifier
fileprivate static var bundleIdentifier: String? = nil
/// Variable that can be set using setBundleIdentifiers
fileprivate static var bundleIdentifiers: [String]? = nil
/**
This method can be used in unit tests to force the bundle where classes can be found
- parameter forClass: The class that will be used to find the appName for in which we can find classes by string.
*/
public class func setBundleIdentifier(_ forClass: AnyClass) {
EVReflection.bundleIdentifier = nameForBundle(Bundle(for:forClass))
}
/**
This method can be used in unit tests to force the bundle where classes can be found
- parameter identifier: The identifier that will be used.
*/
public class func setBundleIdentifier(_ identifier: String) {
EVReflection.bundleIdentifier = identifier
}
/**
This method can be used in project where models are split between multiple modules.
- parameter classes: classes that that will be used to find the appName for in which we can find classes by string.
*/
public class func setBundleIdentifiers(_ classes: Array<AnyClass>) {
bundleIdentifiers = []
for aClass in classes {
bundleIdentifiers?.append(nameForBundle(Bundle(for: aClass)))
}
}
/**
This method can be used in project where models are split between multiple modules.
- parameter identifiers: The array of identifiers that will be used.
*/
public class func setBundleIdentifiers(_ identifiers: Array<String>) {
bundleIdentifiers = []
for identifier in identifiers {
bundleIdentifiers?.append(identifier)
}
}
fileprivate static func nameForBundle(_ bundle: Bundle) -> String {
// get the bundle name from what is set in the infoDictionary
var appName = bundle.infoDictionary?[kCFBundleExecutableKey as String] as? String ?? ""
// If it was not set, then use the bundleIdentifier (which is the same as kCFBundleIdentifierKey)
if appName == "" {
appName = bundle.bundleIdentifier ?? ""
appName = appName.split(whereSeparator: {$0 == "."}).map({ String($0) }).last ?? ""
}
// First character may not be a number
if appName.prefix(1) >= "0" && appName.prefix(1) <= "9" {
appName = "_" + String(appName.dropFirst())
}
// Clean up special characters
return appName.components(separatedBy: illegalCharacterSet).joined(separator: "_")
}
/// This dateformatter will be used when a conversion from string to NSDate is required
fileprivate static var dateFormatter: DateFormatter? = nil
/**
This function can be used to force using an alternat dateformatter for converting String to NSDate
- parameter formatter: The new DateFormatter
*/
public class func setDateFormatter(_ formatter: DateFormatter?) {
dateFormatter = formatter
}
/**
This function is used for getting the dateformatter and defaulting to a standard if it's not set
- returns: The dateformatter
*/
fileprivate class func getDateFormatter() -> DateFormatter {
if let formatter = dateFormatter {
return formatter
}
dateFormatter = DateFormatter()
dateFormatter!.locale = Locale(identifier: "en_US_POSIX")
dateFormatter!.timeZone = TimeZone(secondsFromGMT: 0)
dateFormatter!.dateFormat = "yyyy'-'MM'-'dd' 'HH':'mm':'ssZ"
return dateFormatter!
}
/**
Get the swift Class type from a string
- parameter className: The string representation of the class (name of the bundle dot name of the class)
- returns: The Class type
*/
public class func swiftClassTypeFromString(_ className: String) -> AnyClass? {
if let c = NSClassFromString(className) {
return c
}
// The default did not work. try a combi of appname and classname
if className.range(of: ".", options: NSString.CompareOptions.caseInsensitive) == nil {
let appName = getCleanAppName()
if let c = NSClassFromString("\(appName).\(className)") {
return c
}
}
if let bundleIdentifiers = bundleIdentifiers {
for aBundle in bundleIdentifiers {
if let existingClass = NSClassFromString("\(aBundle).\(className)") {
return existingClass
}
}
}
return nil
}
/**
Get the swift Class from a string
- parameter className: The string representation of the class (name of the bundle dot name of the class)
- returns: The Class type
*/
public class func swiftClassFromString(_ className: String) -> NSObject? {
return (swiftClassTypeFromString(className) as? NSObject.Type)?.init()
}
/**
Get the class name as a string from a swift class
- parameter theObject: An object for whitch the string representation of the class will be returned
- returns: The string representation of the class (name of the bundle dot name of the class)
*/
public class func swiftStringFromClass(_ theObject: NSObject) -> String {
return NSStringFromClass(type(of: theObject)).replacingOccurrences(of: getCleanAppName(theObject) + ".", with: "", options: NSString.CompareOptions.caseInsensitive, range: nil)
}
/**
Get the class name as a string from a swift class
- parameter aClass: An AnyClass for whitch the string representation of the class will be returned
- returns: The string representation of the class (name of the bundle dot name of the class)
*/
public class func swiftStringFromClass(_ aClass: AnyClass) -> String {
return NSStringFromClass(aClass).replacingOccurrences(of: getCleanAppName(aClass) + ".", with: "", options: NSString.CompareOptions.caseInsensitive, range: nil)
}
/**
Helper function to convert an Any to AnyObject
- parameter parentObject: Only needs to be set to the object that has this property when the value is from a property that is an array of optional values
- parameter key: Only needs to be set to the name of the property when the value is from a property that is an array of optional values
- parameter anyValue: Something of type Any is converted to a type NSObject
- parameter conversionOptions: Option set for the various conversion options.
- returns: The value where the Any is converted to AnyObject plus the type of that value as a string
*/
public class func valueForAny(_ parentObject: Any? = nil, key: String? = nil, anyValue: Any, conversionOptions: ConversionOptions = .DefaultDeserialize, isCachable: Bool = false, parents: [NSObject] = []) -> (value: AnyObject, type: String, isObject: Bool) {
var theValue = anyValue
var valueType: String = ""
var mi: Mirror = Mirror(reflecting: theValue)
if mi.displayStyle == .optional {
if mi.children.count == 1 {
theValue = mi.children.first!.value
mi = Mirror(reflecting: theValue)
valueType = String(reflecting:type(of: theValue))
} else if mi.children.count == 0 {
valueType = String(reflecting:type(of: theValue))
var subtype: String = String(valueType[(valueType.components(separatedBy: "<") [0] + "<").endIndex...])
subtype = String(subtype[..<subtype.index(before: subtype.endIndex)])
valueType = convertToInternalSwiftRepresentation(type: subtype)
return (NSNull(), valueType, false)
}
}
if mi.displayStyle == .class {
valueType = String(reflecting:type(of: theValue))
} else if mi.displayStyle == .enum {
valueType = String(reflecting:type(of: theValue))
if let value = theValue as? EVRaw {
theValue = value.anyRawValue
} else if let value = theValue as? EVAssociated {
//let (enumValue, enumType, _) = valueForAny(theValue, key: value.associated.label, anyValue: value.associated.value as Any, conversionOptions: conversionOptions, isCachable: isCachable, parents: parents)
valueType = "Array<Any>"
theValue = value.associated.values
} else if valueType.hasPrefix("Swift.ImplicitlyUnwrappedOptional<") { // Implicitly Unwrapped Optionals are actually fancy enums
var subtype: String = String(valueType[(valueType.components(separatedBy: "<") [0] + "<").endIndex...])
subtype = String(subtype[..<subtype.index(before: subtype.endIndex)])
valueType = convertToInternalSwiftRepresentation(type: subtype)
if mi.children.count == 0 {
return (NSNull(), valueType, false)
}
theValue = mi.children.first?.value ?? theValue
let (val, _, _) = valueForAnyDetail(parentObject, key: key, theValue: theValue, valueType: valueType)
return (val, valueType, false)
} else {
theValue = "\(theValue)"
}
} else if mi.displayStyle == .collection {
valueType = String(reflecting: type(of:theValue))
if valueType.hasPrefix("Swift.Array<Swift.Optional<") {
if let arrayConverter = parentObject as? EVArrayConvertable {
let convertedValue = arrayConverter.convertArray(key!, array: theValue)
return (convertedValue, valueType, false)
}
(parentObject as? EVReflectable)?.addStatusMessage(.MissingProtocol, message: "An object with a property of type Array with optional objects should implement the EVArrayConvertable protocol. type = \(valueType) for key \(key ?? "")")
evPrint(.MissingProtocol, "WARNING: An object with a property of type Array with optional objects should implement the EVArrayConvertable protocol. type = \(valueType) for key \(key ?? "")")
return (NSNull(), "NSNull", false)
}
} else if mi.displayStyle == .dictionary {
valueType = String(reflecting: type(of:theValue))
if let dictionaryConverter = parentObject as? EVReflectable {
let convertedValue = dictionaryConverter.convertDictionary(key!, dict: theValue)
return (convertedValue, valueType, false)
}
} else if mi.displayStyle == .set {
valueType = String(reflecting: type(of:theValue))
if valueType.hasPrefix("Swift.Set<") {
if let arrayConverter = parentObject as? EVArrayConvertable {
let convertedValue = arrayConverter.convertArray(key!, array: theValue)
return (convertedValue, valueType, false)
}
(parentObject as? EVReflectable)?.addStatusMessage(.MissingProtocol, message: "An object with a property of type Set should implement the EVArrayConvertable protocol. type = \(valueType) for key \(key ?? "")")
evPrint(.MissingProtocol, "WARNING: An object with a property of type Set should implement the EVArrayConvertable protocol. type = \(valueType) for key \(key ?? "")")
return (NSNull(), "NSNull", false)
}
} else if mi.displayStyle == .struct {
valueType = String(reflecting: type(of:theValue))
if valueType.contains("Dictionary") {
if let dictionaryConverter = parentObject as? EVReflectable {
let convertedValue = dictionaryConverter.convertDictionary(key!, dict: theValue)
return (convertedValue, valueType, false)
}
} else if valueType == "Foundation.Date" {
return (theValue as! NSDate, "NSDate", false)
} else if valueType == "Foundation.Data" {
return (theValue as! NSData, "NSData", false)
}
let structAsDict = convertStructureToDictionary(theValue, conversionOptions: conversionOptions, isCachable: isCachable, parents: parents)
return (structAsDict, "Struct", false)
} else {
valueType = String(reflecting: type(of:theValue))
}
valueType = convertToInternalSwiftRepresentation(type: valueType)
return valueForAnyDetail(parentObject, key: key, theValue: theValue, valueType: valueType)
}
public class func convertToInternalSwiftRepresentation(type: String) -> String {
if type.split(separator: "<").count > 1 {
// Remove the Array or Set prefix
let prefix = type.split(separator: "<") [0] + "<"
var subtype = String(type[prefix.endIndex...])
subtype = String(subtype[..<subtype.index(before: subtype.endIndex)])
return prefix + convertToInternalSwiftRepresentation(type: subtype) + ">"
}
if type.contains(".") {
var parts = type.components(separatedBy: ".")
if parts.count == 2 {
return parts[1]
}
let c = String(repeating:"C", count: parts.count - 1)
var rv = "_Tt\(c)\(parts[0].count)\(parts[0])"
parts.remove(at: 0)
for part in parts {
rv = "\(rv)\(part.count)\(part)"
}
return rv
}
return type
}
public class func valueForAnyDetail(_ parentObject: Any? = nil, key: String? = nil, theValue: Any, valueType: String) -> (value: AnyObject, type: String, isObject: Bool) {
if theValue is NSNumber {
return (theValue as! NSNumber, "NSNumber", false)
}
if theValue is Int64 {
return (NSNumber(value: theValue as! Int64), "NSNumber", false)
}
if theValue is UInt64 {
return (NSNumber(value: theValue as! UInt64), "NSNumber", false)
}
if theValue is Int32 {
return (NSNumber(value: theValue as! Int32), "NSNumber", false)
}
if theValue is UInt32 {
return (NSNumber(value: theValue as! UInt32), "NSNumber", false)
}
if theValue is Int16 {
return (NSNumber(value: theValue as! Int16), "NSNumber", false)
}
if theValue is UInt16 {
return (NSNumber(value: theValue as! UInt16), "NSNumber", false)
}
if theValue is Int8 {
return (NSNumber(value: theValue as! Int8), "NSNumber", false)
}
if theValue is UInt8 {
return (NSNumber(value: theValue as! UInt8), "NSNumber", false)
}
if theValue is NSString {
return (theValue as! NSString, "NSString", false)
}
if theValue is Date {
return (theValue as AnyObject, "NSDate", false)
}
if theValue is UUID {
return ((theValue as! UUID).uuidString as AnyObject, "NSString", false)
}
if theValue is Array<Any> {
return (theValue as AnyObject, valueType, false)
}
if theValue is EVCustomReflectable {
let value: AnyObject = (theValue as! EVCustomReflectable).toCodableValue() as AnyObject
return (value, valueType, false)
}
if theValue is EVReflectable && theValue is NSObject {
if valueType.contains("<") {
return (theValue as! EVReflectable, swiftStringFromClass(theValue as! NSObject), true)
}
return (theValue as! EVReflectable, valueType, true)
}
if theValue is NSObject {
if valueType.contains("<") {
return (theValue as! NSObject, swiftStringFromClass(theValue as! NSObject), true)
}
if valueType != "_SwiftValue" {
// isObject is false to prevent parsing of objects like CKRecord, CKRecordId and other objects.
return (theValue as! NSObject, valueType, false)
}
}
if valueType.hasPrefix("Swift.Array<") && parentObject is EVArrayConvertable {
return ((parentObject as! EVArrayConvertable).convertArray(key ?? "_unknownKey", array: theValue), valueType, false)
}
(parentObject as? EVReflectable)?.addStatusMessage(.InvalidType, message: "valueForAny unkown type \(valueType) for value: \(theValue).")
evPrint(.InvalidType, "ERROR: valueForAny unkown type \(valueType) for key: \(key ?? "") and value: \(theValue).")
return (NSNull(), "NSNull", false)
}
fileprivate static func convertStructureToDictionary(_ theValue: Any, conversionOptions: ConversionOptions, isCachable: Bool, parents: [NSObject] = []) -> NSDictionary {
let reflected = Mirror(reflecting: theValue)
let (addProperties, _) = reflectedSub(theValue, reflected: reflected, conversionOptions: conversionOptions, isCachable: isCachable, parents: parents)
return addProperties
}
/**
Try to set a value of a property with automatic String to and from Number conversion
- parameter anyObject: the object where the value will be set
- parameter key: the name of the property
- parameter theValue: the value that will be set
- parameter typeInObject: the type of the value
- parameter valid: False if a vaue is expected and a dictionary
- parameter conversionOptions: Option set for the various conversion options.
*/
public static func setObjectValue<T>(_ anyObject: T, key: String, theValue: Any?, typeInObject: String? = nil, valid: Bool, conversionOptions: ConversionOptions = .DefaultDeserialize, parents: [NSObject] = []) where T: NSObject {
guard var value = theValue , (value as? NSNull) == nil else {
return
}
if conversionOptions.contains(.PropertyConverter) {
if let (_, propertySetter, _) = (anyObject as? EVReflectable)?.propertyConverters().filter({$0.0 == key}).first {
propertySetter(value)
return
}
}
if conversionOptions.contains(.Decoding), let ro = anyObject as? EVReflectable {
if let v = ro.decodePropertyValue(value: value, key: key) {
value = v
}
}
// Let us put a number into a string property by taking it's stringValue
let (_, type, _) = valueForAny("", key: key, anyValue: value, conversionOptions: conversionOptions, isCachable: false, parents: parents)
if (typeInObject == "String" || typeInObject == "NSString") && type == "NSNumber" {
if let convertedValue = value as? NSNumber {
value = convertedValue.stringValue as AnyObject
}
} else if typeInObject == "NSNumber" && (type == "String" || type == "NSString") {
if let convertedValue = (value as? String)?.lowercased() {
if convertedValue == "true" || convertedValue == "yes" {
value = 1 as AnyObject
} else if convertedValue == "false" || convertedValue == "no" {
value = 0 as AnyObject
} else {
value = NSNumber(value: Double(convertedValue) ?? 0 as Double)
}
}
} else if typeInObject == "UUID" && (type == "String" || type == "NSString") {
value = UUID(uuidString: value as? String ?? "") as AnyObject? ?? UUID() as AnyObject
} else if typeInObject == "NSURL" && (type == "String" || type == "NSString") {
value = NSURL(string: value as? String ?? "")! as AnyObject
} else if (typeInObject == "NSDate" || typeInObject == "Date") && (type == "String" || type == "NSString") {
if let convertedValue = value as? String {
if let date = getDateFormatter().date(from: convertedValue) {
value = date as AnyObject
} else if let date = Date(fromDateTimeString: convertedValue) {
value = date as AnyObject
} else {
(anyObject as? EVReflectable)?.addStatusMessage(.InvalidValue, message: "The dateformatter returend nil for value \(convertedValue)")
evPrint(.InvalidValue, "WARNING: The dateformatter returend nil for value \(convertedValue)")
return
}
}
} else if typeInObject == "AnyObject" {
}
if !(value is NSArray) && (typeInObject ?? "").contains("Swift.Array") {
value = NSArray(array: [value])
}
if typeInObject == "Struct" {
anyObject.setValue(value, forUndefinedKey: key)
} else {
if !valid {
anyObject.setValue(theValue, forUndefinedKey: key)
return
}
// Call your own object validators that comply to the format: validate<Key>:Error:
do {
if !(value is NSNull) {
var setValue: AnyObject? = value as AnyObject?
let validateFunction = "validate" + key.prefix(1).uppercased() + key.dropFirst() + ":error:"
if (anyObject as AnyObject).responds(to: Selector(validateFunction)) {
try anyObject.validateValue(&setValue, forKey: key)
}
anyObject.setValue(setValue, forKey: key)
}
} catch _ {
(anyObject as? EVReflectable)?.addStatusMessage(.InvalidValue, message: "Not a valid value for object `\(NSStringFromClass(Swift.type(of: (anyObject as AnyObject))))`, type `\(type)`, key `\(key)`, value `\(value)`")
evPrint(.InvalidValue, "INFO: Not a valid value for object `\(NSStringFromClass(Swift.type(of: (anyObject as AnyObject))))`, type `\(type)`, key `\(key)`, value `\(value)`")
}
/* TODO: Do I dare? ... For nullable types like Int? we could use this instead of the workaround.
// Asign pointerToField based on specific type
// Look up the ivar, and it's offset
let ivar: Ivar = class_getInstanceVariable(anyObject.dynamicType, key)
let fieldOffset = ivar_getOffset(ivar)
// Pointer arithmetic to get a pointer to the field
let pointerToInstance = unsafeAddressOf(anyObject)
let pointerToField = UnsafeMutablePointer<Int?>(pointerToInstance + fieldOffset)
// Set the value using the pointer
pointerToField.memory = value!
*/
}
}
// MARK: - Private helper functions
/**
Create a dictionary of all property - key mappings
- parameter theObject: the object for what we want the mapping
- parameter properties: dictionairy of all the properties
- parameter types: dictionairy of all property types.
- returns: dictionairy of the property mappings
*/
fileprivate class func cleanupKeysAndValues(_ theObject: NSObject, properties: NSDictionary, types: NSDictionary) -> (NSDictionary, NSDictionary) {
let newProperties = NSMutableDictionary()
let newTypes = NSMutableDictionary()
for (key, _) in properties {
if let newKey = cleanupKey(theObject, key: (key as? String)!, tryMatch: nil) {
newProperties[newKey] = properties[(key as? String)!]
newTypes[newKey] = types[(key as? String)!]
}
}
return (newProperties, newTypes)
}
/**
Try to map a property name to a json/dictionary key by applying some rules like property mapping, snake case conversion or swift keyword fix.
- parameter anyObject: the object where the key is part of
- parameter key: the key to clean up
- parameter tryMatch: dictionary of keys where a mach will be tried to
- returns: the cleaned up key
*/
fileprivate class func cleanupKey(_ anyObject: NSObject, key: String, tryMatch: NSDictionary?) -> String? {
var newKey: String = key
if tryMatch?[newKey] != nil {
return newKey
}
// Step 1 - clean up keywords
if newKey.first == "_" {
if keywords.contains(String(newKey[newKey.index(newKey.startIndex, offsetBy: 1)...])) {
newKey = String(newKey[newKey.index(newKey.startIndex, offsetBy: 1)...])
if tryMatch?[newKey] != nil {
return newKey
}
}
}
// Step 2 - replace illegal characters
if let t = tryMatch {
for (key, _) in t {
var k = key
if let kIsString = k as? String {
k = processIllegalCharacters(kIsString)
}
if k as? String == newKey {
return key as? String
}
}
}
// Step 3 - from CmelCase or pascalCase
newKey = CamelCaseToPascalCase(newKey)
if tryMatch?[newKey] != nil {
return newKey
}
// Step 4 - from PascalCase or camelCase
newKey = PascalCaseToCamelCase(newKey)
if tryMatch?[newKey] != nil {
return newKey
}
// Step 5 - from camelCase to snakeCase
newKey = camelCaseToUnderscores(newKey)
if tryMatch?[newKey] != nil {
return newKey
}
if tryMatch != nil {
return nil
}
return newKey
}
/// Character that will be replaced by _ from the keys in a dictionary / json
fileprivate static let illegalCharacterSet = CharacterSet(charactersIn: " -&%#@!$^*()<>?.,:;")
/// processIllegalCharacters Cache
fileprivate static var processIllegalCharactersCache = NSCache<NSString, NSString>()
/**
Replace illegal characters to an underscore
- parameter input: key
- returns: processed string with illegal characters converted to underscores
*/
internal static func processIllegalCharacters(_ input: String) -> String {
var p: NSString = ""
if let cachedVersion = processIllegalCharactersCache.object(forKey: input as NSString) {
// use the cached version
p = cachedVersion
} else {
// create it from scratch then store in the cache
p = input.components(separatedBy: illegalCharacterSet).joined(separator: "_") as NSString
processIllegalCharactersCache.setObject(p, forKey: input as NSString)
}
return p as String
}
/// camelCaseToUnderscoresCache Cache
fileprivate static var camelCaseToUnderscoresCache = NSCache<NSString, NSString>()
/**
Convert a CamelCase to Underscores
- parameter input: the CamelCase string
- returns: the underscore string
*/
internal static func camelCaseToUnderscores(_ input: String) -> String {
if input.count == 0 {
return input
}
var p: NSString = ""
if let cachedVersion = camelCaseToUnderscoresCache.object(forKey: input as NSString) {
p = cachedVersion
} else {
var output: String = String(input.first!).lowercased()
let uppercase: CharacterSet = CharacterSet.uppercaseLetters
for character in input[input.index(input.startIndex, offsetBy: 1)...] {
if uppercase.contains(UnicodeScalar(String(character).utf16.first!)!) {
output += "_\(String(character).lowercased())"
} else {
output += "\(String(character))"
}
}
p = output as NSString
camelCaseToUnderscoresCache.setObject(p, forKey: input as NSString)
}
return p as String
}
/**
Convert a CamelCase to pascalCase
- parameter input: the CamelCase string
- returns: the pascalCase string
*/
internal static func PascalCaseToCamelCase(_ input: String) -> String {
if input.count > 1 {
return String(describing: input.first!).lowercased() + input[input.index(after: input.startIndex)...]
}
return input.lowercased()
}
/**
Convert a PascalCase to camelCase
- parameter input: the CamelCase string
- returns: the pascalCase string
*/
internal static func CamelCaseToPascalCase(_ input: String) -> String {
if input.count > 1 {
return String(describing: input.first!).uppercased() + input[input.index(after: input.startIndex)...]
}
return input.uppercased()
}
/// List of swift keywords for cleaning up keys
fileprivate static let keywords = ["self", "description", "class", "deinit", "enum", "extension", "func", "import", "init", "let", "protocol", "static", "struct", "subscript", "typealias", "var", "break", "case", "continue", "default", "do", "else", "fallthrough", "if", "in", "for", "return", "switch", "where", "while", "as", "dynamicType", "is", "new", "super", "Self", "Type", "__COLUMN__", "__FILE__", "__FUNCTION__", "__LINE__", "associativity", "didSet", "get", "infix", "inout", "left", "mutating", "none", "nonmutating", "operator", "override", "postfix", "precedence", "prefix", "right", "set", "unowned", "unowned", "safe", "unowned", "unsafe", "weak", "willSet", "private", "public", "internal", "zone"]
fileprivate static func arrayConversion(_ anyObject: NSObject, key: String, fieldType: String?, original: Any?, theDictValue: Any?, conversionOptions: ConversionOptions = .DefaultDeserialize) -> NSArray {
//Swift.Array<Swift.Array<Swift.Array<A81>>>
let dictValue: NSArray? = theDictValue as? NSArray
if fieldType?.hasPrefix("Swift.Array<Swift.Array<") ?? false && theDictValue is NSArray {
evPrint(.UseWorkaround, "TODO: You have to implement a workaround for double nested arrays. See https://github.com/evermeer/EVReflection/issues/212")
for item in dictValue! {
evPrint(.UseWorkaround, "TODO: Have to convert here... NSArray to \(fieldType ?? "") \(item)")
}
}
return dictValue!
}
/**
Convert a value in the dictionary to the correct type for the object
- parameter anyObject: The object where this dictionary is a property
- parameter key: The property name that is the dictionary
- parameter fieldType: type of the field in object
- parameter original: the original value
- parameter theDictValue: the value from the dictionary
- parameter conversionOptions: Option set for the various conversion options.
- returns: The converted value plus a boolean indicating if it's an object
*/
fileprivate static func dictionaryAndArrayConversion(_ anyObject: NSObject, key: String, fieldType: String?, original: Any?, theDictValue: Any?, conversionOptions: ConversionOptions = .DefaultDeserialize) -> (Any?, Bool) {
var dictValue = theDictValue
var valid = true
if let type = fieldType {
if type.hasPrefix("Swift.Array<") && dictValue is NSArray {
dictValue = arrayConversion(anyObject, key: key, fieldType: fieldType, original: original, theDictValue: theDictValue, conversionOptions: conversionOptions)
}
if type.hasPrefix("Swift.Array<") && dictValue as? NSDictionary != nil {
if (dictValue as? NSDictionary)?.count == 1 {
// XMLDictionary fix
let onlyElement = (dictValue as? NSDictionary)?.makeIterator().next()
//let t: String = ((onlyElement?.key as? String) ?? "")
if onlyElement?.value as? NSArray != nil && type.hasPrefix("Swift.Array<") { // && type.lowercased().hasSuffix("\(t)>")
dictValue = onlyElement?.value as? NSArray
dictValue = dictArrayToObjectArray(anyObject, key: key, type: type, array: (dictValue as? [NSDictionary] as NSArray?) ?? [NSDictionary]() as NSArray, conversionOptions: conversionOptions) as NSArray
} else {
// Single object array fix
var array: [NSDictionary] = [NSDictionary]()
array.append(dictValue as? NSDictionary ?? NSDictionary())
dictValue = dictArrayToObjectArray(anyObject, key: key, type: type, array: array as NSArray, conversionOptions: conversionOptions) as NSArray
}
} else {
// Single object array fix
var array: [NSDictionary] = [NSDictionary]()
array.append(dictValue as? NSDictionary ?? NSDictionary())
dictValue = dictArrayToObjectArray(anyObject, key: key, type: type, array: array as NSArray, conversionOptions: conversionOptions) as NSArray
}
} else if let _ = type.range(of: "_NativeDictionaryStorageOwner"), let dict = dictValue as? NSDictionary, let org = anyObject as? EVReflectable {
dictValue = org.convertDictionary(key, dict: dict)
} else if type != "NSDictionary" && type != "__NSDictionary0" && type != "AnyObject" && dictValue as? NSDictionary != nil { //TODO this too? && original is NSObject
let (dict, isValid) = dictToObject(type, original: original as? NSObject, dict: dictValue as? NSDictionary ?? NSDictionary(), conversionOptions: conversionOptions)
dictValue = dict ?? dictValue
valid = isValid
} else if type.range(of: "<NSDictionary>") == nil && type.range(of: "<AnyObject>") == nil && dictValue as? [NSDictionary] != nil {
// Array of objects
if !(original is EVCustomReflectable) {
dictValue = dictArrayToObjectArray(anyObject, key: key, type: type, array: dictValue as? [NSDictionary] as NSArray? ?? [NSDictionary]() as NSArray, conversionOptions: conversionOptions) as NSArray
}
} else if dictValue is String && original is NSObject && original is EVReflectable {
// fixing the conversion from XML without properties
let (dict, isValid) = dictToObject(type, original:original as? NSObject, dict: ["__text": dictValue as? String ?? ""], conversionOptions: conversionOptions)
dictValue = dict ?? dictValue
valid = isValid
} else if !type.hasPrefix("Swift.Array<") && !type.hasPrefix("Swift.Set<") {
if let array = dictValue as? NSArray {
if anyObject is EVCustomReflectable {
return (array, true)
}
if let org = anyObject as? EVReflectable {
org.addStatusMessage(.InvalidType, message: "Did not expect an array for \(key). Will use the first item instead.")
evPrint(.InvalidType, "WARNING: Did not expect an array for \(key). Will use the first item instead.")
}
if array.count > 0 {
return (array[0] as AnyObject?, true)
}
return (NSNull(), true)
}
}
} else {
}
return (dictValue, valid)
}
/**
Set sub object properties from a dictionary
- parameter type: The object type that will be created
- parameter original: The original value in the object which is used to create a return object
- parameter dict: The dictionary that will be converted to an object
- parameter conversionOptions: Option set for the various conversion options.
- returns: The object that is created from the dictionary
*/
fileprivate class func dictToObject<T>(_ type: String, original: T?, dict: NSDictionary, conversionOptions: ConversionOptions = .DefaultDeserialize) -> (T?, Bool) where T: NSObject {
if var returnObject = original {
if type != "NSNumber" && type != "NSString" && type != "NSDate" && type != "Struct" && type.contains("Dictionary<") == false {
returnObject = setPropertiesfromDictionary(dict, anyObject: returnObject, conversionOptions: conversionOptions)
} else {
if type.contains("Dictionary<") == false && type != "Struct" {
(original as? EVReflectable)?.addStatusMessage(.InvalidClass, message: "Cannot set values on type \(type) from dictionary \(dict)")
evPrint(.InvalidClass, "WARNING: Cannot set values on type \(type) from dictionary \(dict)")
}
return (returnObject, false)
}
return (returnObject, true)
}
var useType = type
if type.hasPrefix("Swift.Optional<") {
var subtype: String = String(type[(type.components(separatedBy: "<") [0] + "<").endIndex...])
subtype = String(subtype[..<subtype.index(before: subtype.endIndex)])
useType = subtype
}
if var returnObject: NSObject = swiftClassFromString(useType) {
if let evResult = returnObject as? EVReflectable {
if let type = evResult.getType(dict) as? NSObject {
returnObject = type
}
if let specific = evResult.getSpecificType(dict) as? NSObject {
returnObject = specific
} else if let evResult = returnObject as? EVGenericsKVC {
returnObject = evResult.getGenericType()
}
}
returnObject = setPropertiesfromDictionary(dict, anyObject: returnObject, conversionOptions: conversionOptions)
return (returnObject as? T, true)
}
if useType != "Struct" {
(original as? EVReflectable)?.addStatusMessage(.InvalidClass, message: "Could not create an instance for type \(type)\ndict:\(dict)")
evPrint(.InvalidClass, "ERROR: Could not create an instance for type \(useType)\ndict:\(dict)")
}
return (nil, false)
}
/**
Create an Array of objects from an array of dictionaries
- parameter type: The object type that will be created
- parameter array: The array of dictionaries that will be converted to the array of objects
- parameter conversionOptions: Option set for the various conversion options.
- returns: The array of objects that is created from the array of dictionaries
*/
fileprivate class func dictArrayToObjectArray(_ anyObject: NSObject, key: String, type: String, array: NSArray, conversionOptions: ConversionOptions = .DefaultDeserialize) -> NSArray {
var subtype = ""
if type.components(separatedBy: "<").count > 1 {
// Remove the Array prefix
subtype = String(type[(type.components(separatedBy: "<") [0] + "<").endIndex...])
subtype = String(subtype[..<subtype.index(before: subtype.endIndex)])
// Remove the optional prefix from the subtype
if subtype.hasPrefix("Optional<") {
subtype = String(subtype[(subtype.components(separatedBy: "<") [0] + "<").endIndex...])
subtype = String(subtype[..<subtype.index(before: subtype.endIndex)])
}
}
var result: [NSObject] = Mirror(reflecting: anyObject).children.filter { $0.label == key }.first?.value as? [NSObject] ?? [NSObject]()
result.removeAll()
for item in array {
let org = getTypeFor(anyObject: anyObject, key: key, type: subtype, item: item)
let (arrayObject, valid) = dictToObject(subtype, original:org, dict: item as? NSDictionary ?? NSDictionary(), conversionOptions: conversionOptions)
if arrayObject != nil && valid {
result.append(arrayObject!)
}
}
return result as NSArray
}
fileprivate class func getTypeFor(anyObject: NSObject, key: String, type: String, item: Any) -> NSObject? {
var org = swiftClassFromString(type)
if let evResult = org as? EVReflectable {
if let type = evResult.getType(item as? NSDictionary ?? NSDictionary()) as? NSObject {
org = type
}
if let specific = evResult.getSpecificType(item as? NSDictionary ?? NSDictionary()) as? NSObject {
org = specific
} else if let evResult = anyObject as? EVGenericsKVC {
org = evResult.getGenericType()
}
}
return org
}
/**
for parsing an object to a dictionary. including properties from it's super class (recursive)
- parameter theObject: The object as is
- parameter reflected: The object parsed using the reflect method.
- parameter conversionOptions: Option set for the various conversion options.
- returns: The dictionary that is created from the object plus an dictionary of property types.
*/
fileprivate class func reflectedSub(_ theObject: Any, reflected: Mirror, conversionOptions: ConversionOptions = .DefaultDeserialize, isCachable: Bool, parents: [NSObject] = []) -> (NSDictionary, NSDictionary) {
let propertiesDictionary = NSMutableDictionary()
let propertiesTypeDictionary = NSMutableDictionary()
// First add the super class propperties
if let superReflected = reflected.superclassMirror {
let (addProperties, addPropertiesTypes) = reflectedSub(theObject, reflected: superReflected, conversionOptions: conversionOptions, isCachable: isCachable, parents: parents)
for (k, v) in addProperties {
if k as? String != "evReflectionStatuses" {
propertiesDictionary.setValue(v, forKey: k as? String ?? "")
propertiesTypeDictionary[k as? String ?? ""] = addPropertiesTypes[k as? String ?? ""]
}
}
}
for property in reflected.children {
if let originalKey: String = property.label {
var skipThisKey = false
var mapKey = originalKey
if mapKey.contains(".") {
mapKey = mapKey.components(separatedBy: ".")[0] // remover the .storage for lazy properties
}
if originalKey == "evReflectionStatuses" {
skipThisKey = true
}
if conversionOptions.contains(.PropertyMapping) {
if let reflectable = theObject as? EVReflectable {
if let mapping = reflectable.propertyMapping().filter({$0.keyInObject == originalKey}).first {
if mapping.keyInResource == nil {
skipThisKey = true
} else {
mapKey = mapping.keyInResource!
}
}
}
}
if !skipThisKey {
var value = property.value
// Convert the Any value to a NSObject value
var (unboxedValue, valueType, isObject) = valueForAny(theObject, key: originalKey, anyValue: value, conversionOptions: conversionOptions, isCachable: isCachable, parents: parents)
if let v = value as? EVCustomReflectable {
unboxedValue = v.toCodableValue() as AnyObject
valueType = String(describing: type(of: v))
isObject = false
}
if conversionOptions.contains(.Encoding), let ro = theObject as? EVReflectable {
unboxedValue = ro.encodePropertyValue(value: unboxedValue, key: originalKey) as AnyObject
}
if conversionOptions.contains(.PropertyConverter) {
// If there is a properyConverter, then use the result of that instead.
if let (_, _, propertyGetter) = (theObject as? EVReflectable)?.propertyConverters().filter({$0.0 == originalKey}).first {
value = propertyGetter() as Any
let (unboxedValue2, _, _) = valueForAny(theObject, key: originalKey, anyValue: value, conversionOptions: conversionOptions, isCachable: isCachable, parents: parents)
unboxedValue = unboxedValue2
}
}
if isObject {
if let obj = unboxedValue as? EVReflectable {
if let json = obj.customConverter() {
unboxedValue = json as AnyObject
} else {
// sub objects will be added as a dictionary itself.
let (dict, _) = toDictionary(unboxedValue as? NSObject ?? NSObject(), conversionOptions: conversionOptions, isCachable: isCachable, parents: parents)
unboxedValue = dict
}
} else {
// sub objects will be added as a dictionary itself.
let (dict, _) = toDictionary(unboxedValue as? NSObject ?? NSObject(), conversionOptions: conversionOptions, isCachable: isCachable, parents: parents)
unboxedValue = dict
}
} else if let array = unboxedValue as? [NSObject] {
var item: Any
if array.count > 0 {
item = array[0]
// Workaround for bug https://bugs.swift.org/browse/SR-3083
if let possibleEnumArray = unboxedValue as? [Any] {
let possibleEnum = possibleEnumArray[0]
if type(of: item) != type(of: possibleEnum) {
item = possibleEnum
var newArray: [AnyObject] = []
for anEnum in possibleEnumArray {
let (value, _, _) = valueForAny(anyValue: anEnum)
newArray.append(value)
}
unboxedValue = newArray as AnyObject
}
}
} else {
item = array.getArrayTypeInstance(array)
}
let (_, _, isObject) = valueForAny(anyValue: item, conversionOptions: conversionOptions, isCachable: isCachable, parents: parents)
if isObject {
// If the items are objects, than add a dictionary of each to the array
var tempValue = [NSDictionary]()
for av in array {
let (dict, _) = toDictionary(av, conversionOptions: conversionOptions, isCachable: isCachable, parents: parents)
tempValue.append(dict)
}
unboxedValue = tempValue as AnyObject
}
}
if conversionOptions.contains(.SkipPropertyValue) {
if let reflectable = theObject as? EVReflectable {
if !reflectable.skipPropertyValue(unboxedValue, key: mapKey) {
propertiesDictionary.setValue(unboxedValue, forKey: mapKey)
propertiesTypeDictionary[mapKey] = valueType
}
} else {
propertiesDictionary.setValue(unboxedValue, forKey: mapKey)
propertiesTypeDictionary[mapKey] = valueType
}
} else {
propertiesDictionary.setValue(unboxedValue, forKey: mapKey)
propertiesTypeDictionary[mapKey] = valueType
}
}
}
}
return (propertiesDictionary, propertiesTypeDictionary)
}
/**
Clean up dictionary so that it can be converted to json
- parameter dict: The dictionairy that
- returns: The cleaned up dictionairy
*/
internal class func convertDictionaryForJsonSerialization(_ dict: NSDictionary, theObject: NSObject) -> NSDictionary {
let dict2: NSMutableDictionary = NSMutableDictionary()
for (key, value) in dict {
dict2.setValue(convertValueForJsonSerialization(value as AnyObject, theObject: theObject), forKey: key as? String ?? "")
}
return dict2
}
/**
Clean up a value so that it can be converted to json
- parameter value: The value to be converted
- returns: The converted value
*/
fileprivate class func convertValueForJsonSerialization(_ value: Any, theObject: NSObject) -> AnyObject {
switch value {
case let stringValue as NSString:
return stringValue
case let numberValue as NSNumber:
return numberValue
case let nullValue as NSNull:
return nullValue
case let arrayValue as NSArray:
let tempArray: NSMutableArray = NSMutableArray()
for value in arrayValue {
tempArray.add(convertValueForJsonSerialization(value as Any, theObject: theObject))
}
return tempArray
case let date as Date:
return getDateFormatter().string(from: date) as NSString
case let reflectable as EVCustomReflectable:
return convertDictionaryForJsonSerialization(reflectable.toCodableValue() as? NSDictionary ?? NSDictionary(), theObject: theObject)
case let reflectable as EVReflectable:
return convertDictionaryForJsonSerialization(reflectable.toDictionary(), theObject: theObject)
case let ok as NSDictionary:
return convertDictionaryForJsonSerialization(ok, theObject: theObject)
case let d as Data:
return d.base64EncodedString() as AnyObject
default:
(theObject as? EVReflectable)?.addStatusMessage(.InvalidType, message: "Unexpected type while converting value for JsonSerialization: \(value)")
evPrint(.InvalidType, "ERROR: Unexpected type while converting value for JsonSerialization: \(value)")
return "\(value)" as AnyObject
}
}
}
extension Date {
public init?(fromDateTimeString: String) {
let pattern = "\\\\?/Date\\((\\d+)(([+-]\\d{2})(\\d{2}))?\\)\\\\?/"
let regex = try! NSRegularExpression(pattern: pattern)
let match: NSRange = regex.rangeOfFirstMatch(in: fromDateTimeString, range: NSRange(location: 0, length: fromDateTimeString.utf16.count))
var dateString: String = ""
if match.location == NSNotFound {
dateString = fromDateTimeString
} else {
dateString = (fromDateTimeString as NSString).substring(with: match) // Extract milliseconds
}
let substrings = dateString.components(separatedBy: CharacterSet.decimalDigits.inverted)
guard let timeStamp = (substrings.compactMap { Double($0) }.first) else { return nil }
self.init(timeIntervalSince1970: timeStamp / 1000.0) // Create Date from timestamp
}
}