ios – 符合通用协议的结构类型,其关联类型也是协议

前端之家收集整理的这篇文章主要介绍了ios – 符合通用协议的结构类型,其关联类型也是协议前端之家小编觉得挺不错的,现在分享给大家,也给大家做个参考。
这很难说,但我已经创建了一个最小的例子.

如果你更喜欢……这是一个要点

“数据项”协议

我有一个协议,它定义了具有类似属性编号的Sortable对象.

  1. protocol Sortable: Comparable {
  2. var number: Int {get}
  3.  
  4. static func < (lhs:Self,rhs: Self) -> Bool
  5. static func == (lhs:Self,rhs: Self) -> Bool
  6. }
  7.  
  8. struct BasicSortable: Sortable {
  9. let number: Int
  10.  
  11. static func < (lhs:BasicSortable,rhs: BasicSortable) -> Bool {
  12. return lhs.number < rhs.number
  13. }
  14.  
  15. static func == (lhs:BasicSortable,rhs: BasicSortable) -> Bool {
  16. return lhs.number == rhs.number
  17. }
  18. }

“工人”协议

然后我有一个协议,可以使用这些Sortable类型做一些事情.但由于它具有自我要求,因此需要将其定义为具有关联类型的协议,并在结构中定义为通用属性

  1. protocol Sorter {
  2. associatedtype Item: Sortable
  3.  
  4. func sort(items: [Item]) -> [Item]
  5. }
  6.  
  7. // Two different sorters
  8. struct AscendingSorter<T:Sortable>: Sorter {
  9. typealias Item = T
  10.  
  11. func sort(items: [T]) -> [T] {
  12. return items.sorted()
  13. }
  14. }
  15.  
  16. struct DescendingSorter<T:Sortable>: Sorter {
  17. typealias Item = T
  18.  
  19. func sort(items: [T]) -> [T] {
  20. return items.sorted{$0 > $1}
  21. }
  22. }

处理程序

最后一个将所有东西拉到一起的结构……

  1. struct DataHandler<T: Sortable> {
  2. let items: [T]
  3. let sortedItems: [T]
  4.  
  5. init(unsortedItems: [T]) {
  6. items = unsortedItems
  7.  
  8. let sorter = AscendingSorter<T>()
  9. sortedItems = sorter.sort(items: unsortedItems)
  10. }
  11. }

让一切顺利

这一切都有效.

  1. let array = [
  2. BasicSortable(number: 1),BasicSortable(number: 8),BasicSortable(number: 13),BasicSortable(number: 3),BasicSortable(number: 4),BasicSortable(number: 14),BasicSortable(number: 5),BasicSortable(number: 12),]
  3.  
  4. let handler = DataHandler(unsortedItems: array)
  5.  
  6. handler.sortedItems

这将根据我在处理程序中创建的分拣机类型以正确的顺序打印出项目数组

问题

我现在要做的是为这个排序器结构找到一个属性声明,可以将任何Sorter类型放入其中,但到目前为止我尝试过的所有内容都失败了.

有没有办法做到这一点?

在结构中,我想…

  1. let sorter: SomeTypeHere

然后在init设置它就像…

  1. sorter = AscendingSorter()

但是我没有试过这样做的组合起作用了.

谢谢

@H_404_48@

解决方法

您可以使用类型擦除来实现自己的AnySorter.

从您自己的代码开始:

  1. protocol Sortable: Comparable {
  2. var number: Int {get}
  3.  
  4. /* as Hamish mentions in his answer:
  5. < and == already blueprinted in Comparable and Equatable */
  6. }
  7.  
  8. protocol Sorter {
  9. associatedtype Item: Sortable
  10.  
  11. func sort(items: [Item]) -> [Item]
  12. }

构造AnySorter:

  1. struct AnySorter<Item: Sortable>: Sorter {
  2. private let _sort: ([Item]) -> [Item]
  3.  
  4. init<S: Sorter where S.Item == Item>(_ sorter: S) {
  5. _sort = sorter.sort
  6. }
  7.  
  8. func sort(items: [Item]) -> [Item] {
  9. return _sort(items)
  10. }
  11. }

您使用的例如作为DataHandler中初始值设定项的参数:

  1. struct DataHandler<T: Sortable> {
  2. let items: [T]
  3. let sortedItems: [T]
  4.  
  5. init(unsortedItems: [T],sorter: AnySorter<T>) {
  6. items = unsortedItems
  7. sortedItems = sorter.sort(items: unsortedItems)
  8. }
  9. }

您的处理程序现在可以与应用于Sortable类型的类型擦除AnySorter一起使用.例如,您在问题中提供的两个简单分拣机:

  1. struct AscendingSorter<T:Sortable>: Sorter {
  2. typealias Item = T
  3.  
  4. func sort(items: [T]) -> [T] {
  5. return items.sorted()
  6. }
  7. }
  8.  
  9. struct DescendingSorter<T:Sortable>: Sorter {
  10. typealias Item = T
  11.  
  12. func sort(items: [T]) -> [T] {
  13. return items.sorted{$0 > $1}
  14. }
  15. }
  16.  
  17. /* example usage */
  18. extension Int: Sortable {
  19. var number: Int { return self }
  20. }
  21.  
  22. let arr = [1,4,2,8,3]
  23.  
  24. let dataHandlerDesc = DataHandler(unsortedItems: arr,sorter: AnySorter(DescendingSorter()))
  25. print(dataHandlerDesc.sortedItems) // [8,3,1]
  26.  
  27. let dataHandlerAsc = DataHandler(unsortedItems: arr,sorter: AnySorter(AscendingSorter()))
  28. print(dataHandlerAsc.sortedItems) // [1,8]

编辑附加内容以回答您的评论

Is it possible to take the input parameter and store it in a property?
Would I just use AnySorter<T> as the type of the property?

是的,您可以使用AnySorter类型在DataHandler中保留属性.例如,对于一个人为的例子,我们可以让sortedItems成为一个计算属性,利用AnySorter实例对存储的项目列表进行排序(当然,实际上我们不希望对每个调用进行重新排序,但是仅适用于此示例!):

  1. struct DataHandler<T: Sortable> {
  2. let items: [T]
  3. var sortedItems: [T] { return sorter.sort(items: items) }
  4. var sorter: AnySorter<T>
  5.  
  6. init(unsortedItems: [T],sorter: AnySorter<T>) {
  7. items = unsortedItems
  8. self.sorter = sorter
  9. }
  10.  
  11. mutating func changeSorter(newSorter: AnySorter<T>) {
  12. sorter = newSorter
  13. }
  14. }
  15.  
  16. /* example usage */
  17. extension Int: Sortable {
  18. var number: Int { return self }
  19. }
  20.  
  21. let arr = [1,3]
  22.  
  23. var dataHandler = DataHandler(unsortedItems: arr,sorter: AnySorter(DescendingSorter()))
  24. print(dataHandler.sortedItems) // [8,1]
  25.  
  26. dataHandler.changeSorter(newSorter: AnySorter(AscendingSorter()))
  27. print(dataHandler.sortedItems) // [1,8]
@H_404_48@ @H_404_48@

猜你在找的iOS相关文章