如何测试另一个快速通用类型？

Question

I have some generic type class but no instance of object to test. What I would like to do is to alter the behavior of the function according to the runtime type.

class MyGenericUtility<SomeGenericClass> {

    func myFunction() {
        // so far I have tested "is", "==" and "==="
        if SomeGenericClass is SomeRealClass {
            println("some special stuff there")
        }
        println("some generic stuff as the name tells")
    }

}

Answer 1

You can compare the class type, using SomeGenericClass.self == SomeRealClass.self as,

class MyGenericUtility<SomeGenericClass> {
    func myFunction() {
        if SomeGenericClass.self == SomeRealClass.self {
            print("SomeRealClass stuffs")
        } else if SomeGenericClass.self == String.self {
            print("String stuffs")
        }
    } 
}


let someRealUtility = MyGenericUtility<SomeRealClass>()
someRealUtility.myFunction()

let stringUtility = MyGenericUtility<String>()
stringUtility.myFunction()

Answer 2

Rather than testing at runtime, you should generally handle this at compile time with constrained extensions (this assumes Swift 2). Doing it this way avoids any need to do unsafe as! casting when you need to access type-specific parts of the instance.

class MyGenericUtility<SomeGenericClass> {
}

// Special handling for `SomeRealClass`
extension MyGenericUtility where SomeGenericClass: SomeRealClass {
    func myFunction() {
        print("SomeRealClass stuffs")
    }
}

// Default handling for any unspecified class
extension MyGenericUtility {
    func myFunction() {
        print("Other stuffs")
    }
}

let someRealUtility = MyGenericUtility<SomeRealClass>()
someRealUtility.myFunction()

let stringUtility = MyGenericUtility<String>()
stringUtility.myFunction()

Note that this is based on inheritance, not equality, so any subclass of SomeRealClass would get the SomeRealClass behavior.

Answer 3

You can't use the generic type directly, you need to use a property of that type when comparing with "is".

class MyGenericUtility<T> {
    var a: T

    func myFunction() {
        if a is Int {
            println("some special stuff there")
        }
        println("some generic stuff as the name tells")
    }

    init(value: T) {
        a = value
    }
}

let test = MyGenericUtility(value: 5)
test.myFunction()  
// Output: some special stuff there
//         some generic stuff as the name tells

let test2 = MyGenericUtility(value: "foo")
test2.myFunction()
// Output: some generic stuff as the name tells