Change storage access to leverage AnyExtensions

Author: bradhilton

Sources/Reflection/Any+Extensions.swift

@@ -18,6 +18,10 @@ extension AnyExtensions {
         return try Reflection.construct(self, dictionary: dictionary)
     }
 
+    static func value(from pointer: UnsafeRawPointer) -> Any {
+        return pointer.assumingMemoryBound(to: self).pointee
+    }
+    
     func write(to pointer: UnsafeMutableRawPointer) {
         pointer.assumingMemoryBound(to: type(of: self)).initialize(to: self)
     }

Sources/Reflection/Get.swift

@@ -1,11 +1,9 @@
 /// Get value for key from instance
 public func get(_ key: String, from instance: Any) throws -> Any {
-    for property in try properties(instance) {
-        if property.key == key {
-            return property.value
-        }
+    guard let value = try properties(instance).first(where: { $0.key == key })?.value else {
+        throw ReflectionError.instanceHasNoKey(type: type(of: instance), key: key)
     }
-    throw ReflectionError.instanceHasNoKey(type: type(of: instance), key: key)
+    return value
 }
 
 /// Get value for key from instance as type `T`

Sources/Reflection/Properties.swift

@@ -27,18 +27,15 @@ public struct Property {
 /// Retrieve properties for `instance`
 public func properties(_ instance: Any) throws -> [Property] {
     let props = try properties(type(of: instance))
-    var copy = instance
-    let storage = storageForInstance(&copy)
+    var copy = extensions(of: instance)
+    let storage = copy.storage()
     return props.map { nextProperty(description: $0, storage: storage) }
 }
 
 private func nextProperty(description: Property.Description, storage: UnsafeRawPointer) -> Property {
     return Property(
         key: description.key,
-        value: AnyExistentialContainer(
-            type: description.type,
-            pointer: storage.advanced(by: description.offset)
-        ).any
+        value: extensions(of: description.type).value(from: storage.advanced(by: description.offset))
     )
 }
 

Sources/Reflection/Set.swift

@@ -1,7 +1,7 @@
 /// Set value for key of an instance
 public func set(_ value: Any, key: String, for instance: inout Any) throws {
-    let property = try propertyForType(type(of: instance), withName: key)
-    try setValue(value, forKey: key, property: property, storage: mutableStorageForInstance(&instance))
+    let property = try Reflection.property(type: type(of: instance), key: key)
+    try setValue(value, forKey: key, property: property, storage: mutableStorage(instance: &instance))
 }
 
 /// Set value for key of an instance
@@ -12,12 +12,12 @@ public func set(_ value: Any, key: String, for instance: AnyObject) throws {
 
 /// Set value for key of an instance
 public func set<T>(_ value: Any, key: String, for instance: inout T) throws {
-    let property = try propertyForType(T.self, withName: key)
-    try setValue(value, forKey: key, property: property, storage: mutableStorageForInstance(&instance))
+    let property = try Reflection.property(type: T.self, key: key)
+    try setValue(value, forKey: key, property: property, storage: mutableStorage(instance: &instance))
 }
 
-private func propertyForType(_ type: Any.Type, withName key: String) throws -> Property.Description {
-    guard let property = try properties(type).filter({ $0.key == key }).first else { throw ReflectionError.instanceHasNoKey(type: type, key: key) }
+private func property(type: Any.Type, key: String) throws -> Property.Description {
+    guard let property = try properties(type).first(where: { $0.key == key }) else { throw ReflectionError.instanceHasNoKey(type: type, key: key) }
     return property
 }
 

Sources/Reflection/Storage.swift

@@ -1,24 +1,20 @@
-func mutableStorageForInstance(_ instance: inout Any) -> UnsafeMutableRawPointer {
-    return UnsafeMutableRawPointer(mutating: storageForInstance(&instance))
-}
-
-func storageForInstance(_ instance: inout Any) -> UnsafeRawPointer {
-    return withUnsafePointer(to: &instance) { pointer in
-        if type(of: instance) is AnyClass {
-            return UnsafeRawPointer(bitPattern: UnsafePointer<Int>(pointer).pointee)!
-        } else if sizeofValue(instance) <= 3 * sizeof(Int.self) {
-            return UnsafeRawPointer(pointer)
-        } else {
-            return UnsafeRawPointer(bitPattern: UnsafePointer<Int>(pointer).pointee)!
-        }
+extension AnyExtensions {
+    
+    mutating func mutableStorage() -> UnsafeMutableRawPointer {
+        return Reflection.mutableStorage(instance: &self)
+    }
+    
+    mutating func storage() -> UnsafeRawPointer {
+        return Reflection.storage(instance: &self)
     }
+    
 }
 
-func mutableStorageForInstance<T>(_ instance: inout T) -> UnsafeMutableRawPointer {
-    return UnsafeMutableRawPointer(mutating: storageForInstance(&instance))
+func mutableStorage<T>(instance: inout T) -> UnsafeMutableRawPointer {
+    return UnsafeMutableRawPointer(mutating: storage(instance: &instance))
 }
 
-func storageForInstance<T>(_ instance: inout T) -> UnsafeRawPointer {
+func storage<T>(instance: inout T) -> UnsafeRawPointer {
     return withUnsafePointer(to: &instance) { pointer in
         if type(of: instance) is AnyClass {
             return UnsafeRawPointer(bitPattern: UnsafePointer<Int>(pointer).pointee)!