কীভাবে সুইফটে জেনেরিক প্রোটোকল তৈরি করবেন?

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আপনি তা এভাবেই করুন:

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"))