Ios 如何创建一个通用顶点，以便创建混合类型的图（集合）？

我在设计顶点结构时遇到问题。我希望能够创建“数组”或“集合”，这样我的“顶点”就不必都是相同的类型。这两种情况都会产生不同的错误。检查下面的代码

先谢谢你

import Foundation

public struct Vertex<T: Equatable> where  T: Equatable, T: Hashable {

    public var data: T
    public let index: Int?

    init(data: T , index: Int ) {
        self.data = data
        self.index = index
      }

}

extension Vertex: CustomStringConvertible {

    public var description: String {
        return "\(index): \(data)"
    }

}

struct Coordinate {
    var x : Int
    var y : Int

    init(x : Int, y: Int) {
        self.x = x
        self.y = y
    }

}
extension Coordinate: Equatable {}

func ==(lhs: Coordinate, rhs: Coordinate) -> Bool {
    guard lhs.x == rhs.x else {
        return false
    }

    guard lhs.y == rhs.y else {
        return false
    }
    return true
}

extension Coordinate: Hashable {
    var hashValue: Int {
        return "\(x)\(y)".hashValue
    }
}




let coord1  = Coordinate(x : 5, y: 5)
let stringVertex1  = Vertex(data: "Hello World", index: 3)
let stringVertex2  = Vertex(data: "Foo ", index: 3)
let intVertex1  = Vertex(data: 2, index: 1)
let coordVertex1  = Vertex(data: coord1, index: 1)


//Error: Cannot convert value of type 'Vertex<String>' to expected element type 'Vertex'. 
//Even if I make myArr1 equal to [stringVertex1, stringVertex1], I still get the same error.
let myArr1 : Array<Vertex> = [stringVertex1, intVertex1]

//This works since the data inside "Vertex" is the same type.
let myArr2 : Array<Vertex<String>> = [stringVertex1, stringVertex2]

//Error: Type "Vertex" does not conform to protocol "Hashable". 
let mySet1 : Set<Vertex> = [stringVertex1, stringVertex2]

<代码>导入基础 公共结构顶点，其中T:equalable，T:Hashable{ 公共var数据：T 公共let索引：Int？ init（数据：T，索引：Int）{ self.data=数据 self.index=索引 } } 扩展顶点：CustomStringConvertible{ 公共变量说明：字符串{ 返回“\（索引）：\（数据）” } } 结构坐标{ 变量x:Int 变量y:Int init（x:Int，y:Int）{ self.x=x self.y=y } } 扩展坐标：可等式{} func==（左：坐标，右：坐标）->Bool{ 防护装置lhs.x==rhs.x else{ 返回错误 } 防护罩lhs.y==rhs.y else{ 返回错误 } 返回真值 } 扩展坐标：可散列{ var hashValue:Int{ 返回“\（x）\（y）”.hashValue } } 设coord1=坐标（x:5，y:5） 让stringVertex1=顶点（数据：“Hello World”，索引：3） 设stringVertex2=顶点（数据：“Foo”，索引：3） 设intVertex1=顶点（数据：2，索引：1） 设coordVertex1=顶点（数据：coord1，索引：1） //错误：无法将“Vertex”类型的值转换为预期的元素类型“Vertex”。 //即使我使myArr1等于[stringVertex1，stringVertex1]，我仍然会得到相同的错误。 让myArr1:Array=[stringVertex1，intVertex1] //这是因为“顶点”内的数据类型相同。 让myArr2:Array=[stringVertex1，stringVertex2] //错误：类型“Vertex”不符合协议“Hashable”。 让mySet1:Set=[stringVertex1，stringVertex2]

---

我得到了答案。这是最终的顶点代码。流行音乐的力量

public enum TypeOfVertex : String {
    case Int = "Mirror for Int"
    case Float = "Mirror for Float"
    case Double = "Mirror for Double"
    case Coordinates = "Mirror for Coordinate"
    case String = "Mirror for String"

}


protocol AnyVertexable {
    var type: TypeOfVertex { get set }
    var index: Int { get set }

}


struct Vertex<Element : Hashable> : AnyVertexable where Element: Equatable & Hashable {

    var type : TypeOfVertex
    var index: Int
    var data : Element?

    init(index: Int, data: Element) {
        self.data = data
        self.index = index
        if let type = TypeOfVertex(rawValue: data.hashValue.customMirror.description) {
           self.type = type
        } else {
           fatalError()
        }
    }

}

let sample1 = Vertex(index: 0, data: 1.0)
let sample2 = Vertex(index: 2, data: 1)
let sample3 = Vertex(index: 3, data: Coordinate(x: 5, y: 5))

let myArr : [AnyVertexable] = [sample1, sample2, sample3]

public enum TypeOfVertex:String{
case Int=“镜像用于Int”
case Float=“用于浮动的镜像”
case Double=“双面镜”
案例坐标=“坐标的镜像”
case String=“字符串的镜像”
}
协议AnyVertexable{
变量类型：TypeOfVertex{get set}
变量索引：Int{get set}
}
结构顶点：AnyVertexable，其中元素：equalable&Hashable{
变量类型：TypeOfVertex
var指数：Int
var数据：元素？
init（索引：Int，数据：Element）{
self.data=数据
self.index=索引
如果let type=TypeOfVertex（rawValue:data.hashValue.customMirror.description）{
self.type=type
}否则{
法塔莱罗（）
}
}
}
让sample1=顶点（索引：0，数据：1.0）
设sample2=顶点（索引：2，数据：1）
让sample3=顶点（索引：3，数据：坐标（x:5，y:5））
让myArr:[AnyVertexable]=[sample1，sample2，sample3]

我得到了答案。这是最终的顶点代码。流行音乐的力量

public enum TypeOfVertex : String {
    case Int = "Mirror for Int"
    case Float = "Mirror for Float"
    case Double = "Mirror for Double"
    case Coordinates = "Mirror for Coordinate"
    case String = "Mirror for String"

}


protocol AnyVertexable {
    var type: TypeOfVertex { get set }
    var index: Int { get set }

}


struct Vertex<Element : Hashable> : AnyVertexable where Element: Equatable & Hashable {

    var type : TypeOfVertex
    var index: Int
    var data : Element?

    init(index: Int, data: Element) {
        self.data = data
        self.index = index
        if let type = TypeOfVertex(rawValue: data.hashValue.customMirror.description) {
           self.type = type
        } else {
           fatalError()
        }
    }

}

let sample1 = Vertex(index: 0, data: 1.0)
let sample2 = Vertex(index: 2, data: 1)
let sample3 = Vertex(index: 3, data: Coordinate(x: 5, y: 5))

let myArr : [AnyVertexable] = [sample1, sample2, sample3]

public enum TypeOfVertex:String{
case Int=“镜像用于Int”
case Float=“用于浮动的镜像”
case Double=“双面镜”
案例坐标=“坐标的镜像”
case String=“字符串的镜像”
}
协议AnyVertexable{
变量类型：TypeOfVertex{get set}
变量索引：Int{get set}
}
结构顶点：AnyVertexable，其中元素：equalable&Hashable{
变量类型：TypeOfVertex
var指数：Int
var数据：元素？
init（索引：Int，数据：Element）{
self.data=数据
self.index=索引
如果let type=TypeOfVertex（rawValue:data.hashValue.customMirror.description）{
self.type=type
}否则{
法塔莱罗（）
}
}
}
让sample1=顶点（索引：0，数据：1.0）
设sample2=顶点（索引：2，数据：1）
让sample3=顶点（索引：3，数据：坐标（x:5，y:5））
让myArr:[AnyVertexable]=[sample1，sample2，sample3]

与其尝试滚动您自己的图形框架，您可能希望使用一个已经测试并支持通用顶点的框架：虽然我是作者，但我有点偏见。对于第一个错误，您需要为

坐标
实现
哈希表
协议。对于第二个错误，您需要一个类型橡皮擦，
any橡皮擦
，它可以擦除特定类型的顶点，并将其视为任何其他@Muhammad绝对没有任何意义。@Muhammad但是String、double和int都已经可以散列了。。。问题出在哪里？与其尝试滚动自己的图形框架，不如使用一个已经过测试并支持通用顶点的框架：虽然我是作者，但我有点偏见。对于第一个错误，您需要为
坐标
实现
哈希表
协议。对于第二个错误，您需要一个类型橡皮擦，
any橡皮擦
，它可以擦除特定类型的顶点，并将其视为任何其他@Muhammad绝对没有任何意义。@Muhammad但是String、double和int都已经可以散列了。。。问题在哪里？