Parity: NSMeasurement, NSObject class methods

 - Implement NSMeasurement
 - Implement NSObject’s .isKind(of:), .isMember(of:), .isSubclass(of:) and .superclass.

Author: millenomi

Foundation/NSMeasurement.swift

@@ -10,28 +10,74 @@
 //
 //===----------------------------------------------------------------------===//
 
-
 open class NSMeasurement : NSObject, NSCopying, NSSecureCoding {
     open private(set) var unit: Unit
     open private(set) var doubleValue: Double
 
-    @available(*, unavailable)
-    public convenience override init() { fatalError("Measurements must be constructed with a value and unit") }
-    
     public init(doubleValue: Double, unit: Unit) {
-        self.doubleValue = doubleValue
         self.unit = unit
+        self.doubleValue = doubleValue
     }
 
-    open func canBeConverted(to unit: Unit) -> Bool { NSUnimplemented() }
+    open func canBeConverted(to unit: Unit) -> Bool {
+        return self.unit is Dimension && unit is Dimension && type(of: unit).isSubclass(of: type(of: self.unit))
+    }
 
-    open func converting(to unit: Unit) -> Measurement<Unit> { NSUnimplemented() }
+    open func converting(to otherUnit: Unit) -> Measurement<Unit> {
+        precondition(canBeConverted(to: otherUnit))
+        
+        if unit.isEqual(otherUnit) {
+            return Measurement(value: doubleValue, unit: otherUnit)
+        } else {
+            let dimensionUnit = unit as! Dimension
+            
+            let valueInTermsOfBase = dimensionUnit.converter.baseUnitValue(fromValue: doubleValue)
+            if otherUnit.isEqual(type(of: dimensionUnit).baseUnit()) {
+                return Measurement(value: valueInTermsOfBase, unit: otherUnit)
+            } else {
+                let otherDimensionUnit = otherUnit as! Dimension
+                
+                let otherValueFromTermsOfBase = otherDimensionUnit.converter.value(fromBaseUnitValue: valueInTermsOfBase)
+                return Measurement(value: otherValueFromTermsOfBase, unit: otherUnit)
+            }
+        }
+    }
 
-    open func adding(_ measurement: Measurement<Unit>) -> Measurement<Unit> { NSUnimplemented() }
+    open func adding(_ rhs: Measurement<Unit>) -> Measurement<Unit> {
+        precondition(unit is Dimension)
+        precondition(rhs.unit is Dimension)
+        
+        let dimensionUnit = unit as! Dimension
+        let rhsDimensionUnit = rhs.unit as! Dimension
+        
+        if unit.isEqual(rhs.unit) {
+            return Measurement(value: doubleValue + rhs.value, unit: unit)
+        } else {
+            let lhsValueInTermsOfBase = dimensionUnit.converter.baseUnitValue(fromValue: doubleValue)
+            let rhsValueInTermsOfBase = rhsDimensionUnit.converter.baseUnitValue(fromValue: rhs.value)
+            return Measurement(value: lhsValueInTermsOfBase + rhsValueInTermsOfBase, unit: type(of: dimensionUnit).baseUnit())
+        }
+    }
 
-    open func subtracting(_ measurement: Measurement<Unit>) -> Measurement<Unit> { NSUnimplemented() }
+    open func subtracting(_ rhs: Measurement<Unit>) -> Measurement<Unit> {
+        precondition(unit is Dimension)
+        precondition(rhs.unit is Dimension)
+        
+        let dimensionUnit = unit as! Dimension
+        let rhsDimensionUnit = rhs.unit as! Dimension
+        
+        if unit.isEqual(rhs.unit) {
+            return Measurement(value: doubleValue - rhs.value, unit: unit)
+        } else {
+            let lhsValueInTermsOfBase = dimensionUnit.converter.baseUnitValue(fromValue: doubleValue)
+            let rhsValueInTermsOfBase = rhsDimensionUnit.converter.baseUnitValue(fromValue: rhs.value)
+            return Measurement(value: lhsValueInTermsOfBase - rhsValueInTermsOfBase, unit: type(of: dimensionUnit).baseUnit())
+        }
+    }
 
-    open func copy(with zone: NSZone? = nil) -> Any { NSUnimplemented() }
+    open func copy(with zone: NSZone? = nil) -> Any {
+        return self
+    }
 
     open class var supportsSecureCoding: Bool { return true }
 

Foundation/NSObject.swift

@@ -12,6 +12,13 @@
 // This brings it into line with Darwin usage for compatibility.
 @_exported import Dispatch
 
+#if canImport(ObjectiveC)
+import ObjectiveC
+#else
+@_silgen_name("_swift_class_getSuperclass")
+internal func _swift_class_getSuperclass(_ t: AnyClass) -> AnyClass?
+#endif
+
 import CoreFoundation
 
 /// The `NSObjectProtocol` groups methods that are fundamental to all Foundation objects.
@@ -361,6 +368,52 @@ open class NSObject : NSObjectProtocol, Equatable, Hashable {
     public static func ==(lhs: NSObject, rhs: NSObject) -> Bool {
         return lhs.isEqual(rhs)
     }
+    
+    // Please note:
+    // the following methods are not overridable in swift-corelibs-foundation.
+    
+    private class var nsObjectSuperclass: NSObject.Type? {
+        // Pretend that {Swift,}Foundation.NSObject is the top of the class hierarchy.
+        // On Darwin, avoids dipping into the class hierarchy that exists above this class,
+        // which is ultimately rooted in the ObjC NSObject class.
+        guard !(self == NSObject.self) else { return nil }
+        
+        let actualSuperclass: NSObject.Type
+        
+        #if canImport(ObjectiveC)
+        actualSuperclass = class_getSuperclass(self) as! NSObject.Type
+        #else
+        actualSuperclass = _swift_class_getSuperclass(self) as! NSObject.Type
+        #endif
+        
+        return actualSuperclass
+    }
+    
+    public class var superclass: AnyClass? {
+        return nsObjectSuperclass
+    }
+    
+    /// Returns a Boolean value that indicates whether the receiving
+    /// class is a subclass of, or identical to, a given class.
+    public class func isSubclass(of aClass: AnyClass) -> Bool {
+        var checkedClass: NSObject.Type? = self
+        while let thisClass = checkedClass {
+            if thisClass === aClass {
+                return true
+            }
+            checkedClass = thisClass.nsObjectSuperclass
+        }
+        
+        return false
+    }
+    
+    public func isMember(of aClass: AnyClass) -> Bool {
+        return type(of: self) === aClass
+    }
+    
+    public func isKind(of aClass: AnyClass) -> Bool {
+        return type(of: self).isSubclass(of: aClass)
+    }
 }
 
 extension NSObject : CustomDebugStringConvertible {