स्विफ्ट में जेनेरिक प्रोटोकॉल कैसे बनाएं?

Question 1

मैं एक विधि के साथ एक प्रोटोकॉल बनाना चाहता हूं जो एक सामान्य इनपुट लेता है और एक सामान्य मूल्य देता है।

यह वही है जो मैंने अब तक कोशिश की है, लेकिन यह सिंटैक्स त्रुटि पैदा करता है।

अघोषित पहचानकर्ता का उपयोग टी।

मैं क्या गलत कर रहा हूं?

protocol ApiMapperProtocol {
    func MapFromSource(T) -> U
}

class UserMapper: NSObject, ApiMapperProtocol {
    func MapFromSource(data: NSDictionary) -> UserModel {
        var user = UserModel() as UserModel
        var accountsData:NSArray = data["Accounts"] as NSArray     
        return user
    } 
}

Question 2

यह प्रोटोकॉल के लिए थोड़ा अलग है। एप्पल के प्रलेखन में "एसोसिएटेड प्रकार" को देखें ।

यह आप अपने उदाहरण में इसका उपयोग कैसे करते हैं

protocol ApiMapperProtocol {
    associatedtype T
    associatedtype U
    func MapFromSource(_:T) -> U
}

class UserMapper: NSObject, ApiMapperProtocol {
    typealias T = NSDictionary
    typealias U = UserModel

    func MapFromSource(_ data:NSDictionary) -> UserModel {
        var user = UserModel()
        var accountsData:NSArray = data["Accounts"] as NSArray
        // For Swift 1.2, you need this line instead
        // var accountsData:NSArray = data["Accounts"] as! NSArray
        return user
    }
}

Question 3

पर व्याख्या करने के लिए लो फ्रेंको जवाब एक सा है, तो आप एक विधि है कि एक विशेष इस्तेमाल किया बनाना चाहता था, तो ApiMapperProtocolआप ऐसा thusly कार्य करें:

protocol ApiMapperProtocol {
    associatedtype T
    associatedtype U
    func mapFromSource(T) -> U
}

class UserMapper: NSObject, ApiMapperProtocol {
    // these typealiases aren't required, but I'm including them for clarity
    // Normally, you just allow swift to infer them
    typealias T = NSDictionary 
    typealias U = UserModel

    func mapFromSource(data: NSDictionary) -> UserModel {
        var user = UserModel()
        var accountsData: NSArray = data["Accounts"] as NSArray
        // For Swift 1.2, you need this line instead
        // var accountsData: NSArray = data["Accounts"] as! NSArray
        return user
    }
}

class UsesApiMapperProtocol {
    func usesApiMapperProtocol<
        SourceType,
        MappedType,
        ApiMapperProtocolType: ApiMapperProtocol where
          ApiMapperProtocolType.T == SourceType,
          ApiMapperProtocolType.U == MappedType>(
          apiMapperProtocol: ApiMapperProtocolType, 
          source: SourceType) -> MappedType {
        return apiMapperProtocol.mapFromSource(source)
    }
}

UsesApiMapperProtocolअब केवल SourceTypeदिए गए के साथ संगत स्वीकार करने की गारंटी है ApiMapperProtocol:

let dictionary: NSDictionary = ...
let uses = UsesApiMapperProtocol()
let userModel: UserModel = uses.usesApiMapperProtocol(UserMapper()
    source: dictionary)

Question 4

जेनेरिक प्राप्त करने के लिए और साथ ही इसे इस तरह घोषित let userMapper: ApiMapperProtocol = UserMapper()करने के लिए आपको एक जेनेरिक क्लास को प्रोटोकॉल के अनुरूप होना चाहिए जो एक जेनेरिक तत्व देता है।

protocol ApiMapperProtocol {
    associatedtype I
    associatedType O
    func MapFromSource(data: I) -> O
}

class ApiMapper<I, O>: ApiMapperProtocol {
    func MapFromSource(data: I) -> O {
        fatalError() // Should be always overridden by the class
    }
}

class UserMapper: NSObject, ApiMapper<NSDictionary, UserModel> {
    override func MapFromSource(data: NSDictionary) -> UserModel {
        var user = UserModel() as UserModel
        var accountsData:NSArray = data["Accounts"] as NSArray     
        return user
    } 
}

अब आप इसका भी उल्लेख कर सकते हैं userMapper, ApiMapperजिसके प्रति एक विशिष्ट कार्यान्वयन है UserMapper:

let userMapper: ApiMapper = UserMapper()
let userModel: UserModel = userMapper.MapFromSource(data: ...)

Question 5

कैसे उपयोग करें और सामान्य व्यावसायिक उपयोग करें

प्रोटोकॉल जेनेरिक {

associatedtype T
associatedtype U

func operation(_ t:T)->U

}

// जेनेरिक प्रोटोकॉल का उपयोग करें

संरचना परीक्षण: सामान्य {

typealias T = UserModel
typealias U = Any

func operation(_ t: UserModel)->Any {
    let dict = ["name":"saurabh"]
    return dict
    
}

}

Question 6

आप प्रकार-मिटाने के साथ टेम्पलेट विधियों का उपयोग कर सकते हैं ...

protocol HeavyDelegate : class {
  func heavy<P, R>(heavy: Heavy<P, R>, shouldReturn: P) -> R
}  

class Heavy<P, R> {
    typealias Param = P
    typealias Return = R
    weak var delegate : HeavyDelegate?  
    func inject(p : P) -> R? {  
        if delegate != nil {
            return delegate?.heavy(self, shouldReturn: p)
        }  
        return nil  
    }
    func callMe(r : Return) {
    }
}
class Delegate : HeavyDelegate {
    typealias H = Heavy<(Int, String), String>

    func heavy<P, R>(heavy: Heavy<P, R>, shouldReturn: P) -> R {
        let h = heavy as! H
        h.callMe("Hello")
        print("Invoked")
        return "Hello" as! R
    }  
}

let heavy = Heavy<(Int, String), String>()
let delegate = Delegate()
heavy.delegate = delegate
heavy.inject((5, "alive"))