 
     override public func setValue(value: AnyObject?, forUndefinedKey key: String) {
         // implement in subclass if needed
+    }
+
+    override public func valueForKey(key: String) -> AnyObject? {
+        if !self.respondsToSelector(Selector(key)) {
+            let ivar = class_getInstanceVariable(self.dynamicType, key)
+            if let type = self.properties.filter({ $0.name == key }).first?.type where ivar.hashValue != 0 {
+                let address = ObjectIdentifier(self).uintValue + UInt(ivar_getOffset(ivar))
+
+                if type == Int.self || type == Optional<Int>.self {
+                    let pointer = UnsafeMutablePointer<Int?>(bitPattern: address)
+                    return pointer.memory
+                }
+
+                if type == Int8.self || type == Optional<Int8>.self {
+                    let pointer = UnsafeMutablePointer<Int8?>(bitPattern: address)
+                    return pointer.memory as? AnyObject
+                }
+
+                if type == Int16.self || type == Optional<Int16>.self {
+                    let pointer = UnsafeMutablePointer<Int16?>(bitPattern: address)
+                    return pointer.memory as? AnyObject
+                }
+
+                if type == Int32.self || type == Optional<Int32>.self {
+                    let pointer = UnsafeMutablePointer<Int32?>(bitPattern: address)
+                    return pointer.memory as? AnyObject
+                }
+
+                if type == Int64.self || type == Optional<Int64>.self {
+                    let pointer = UnsafeMutablePointer<Int64?>(bitPattern: address)
+                    return pointer.memory as? AnyObject
+                }
+
+                if type == UInt.self || type == Optional<UInt>.self {
+                    let pointer = UnsafeMutablePointer<UInt?>(bitPattern: address)
+                    return pointer.memory
+                }
+
+                if type == UInt8.self || type == Optional<UInt8>.self {
+                    let pointer = UnsafeMutablePointer<UInt8?>(bitPattern: address)
+                    return pointer.memory as? AnyObject
+                }
+
+                if type == UInt16.self || type == Optional<UInt16>.self {
+                    let pointer = UnsafeMutablePointer<UInt16?>(bitPattern: address)
+                    return pointer.memory as? AnyObject
+                }
+
+                if type == UInt32.self || type == Optional<UInt32>.self {
+                    let pointer = UnsafeMutablePointer<UInt32?>(bitPattern: address)
+                    return pointer.memory as? AnyObject
+                }
+
+                if type == UInt64.self || type == Optional<UInt64>.self {
+                    let pointer = UnsafeMutablePointer<UInt64?>(bitPattern: address)
+                    return pointer.memory as? AnyObject
+                }
+
+                if type == Float.self || type == Optional<Float>.self {
+                    let pointer = UnsafeMutablePointer<Float?>(bitPattern: address)
+                    return pointer.memory
+                }
+
+                if type == Double.self || type == Optional<Double>.self {
+                    let pointer = UnsafeMutablePointer<Double?>(bitPattern: address)
+                    return pointer.memory
+                }
+
+                if type == CGFloat.self || type == Optional<CGFloat>.self {
+                    let pointer = UnsafeMutablePointer<CGFloat?>(bitPattern: address)
+                    return pointer.memory
+                }
+
+                if type == Bool.self || type == Optional<Bool>.self {
+                    let pointer = UnsafeMutablePointer<Bool?>(bitPattern: address)
+                    return pointer.memory
+                }
+            }
+        }
+        return super.valueForKey(key)
     }
 
     public func toDictionary(nulls: Bool = false) -> Dict {

    }

    public override func setValue(value: AnyObject?, forKey key: String) {
        let setter = self.dynamicType.propertySetterNameForKey(key)
        if !self.respondsToSelector(Selector(setter)) {
            return self.setValue(value, forUndefinedKey: key)
        }

        if let property = self.properties.filter({ $0.name == key }).first {
            if value == nil {
                super.setValue(value, forKey: key)
                return
            }

            let type = property.type

            // String
            if type == String.self || type == Optional<String>.self {


            // Integer Enum
            else if let enumType = property.type as? SuperEnum.Type {
                super.setValue(self.dynamicType.numberFromValue(value), forKey: key)
            }

            // What else?
