ios - 快速枚举类

Question

我正在尝试创建一个具有类型和返回所有类型的函数的枚举类。

最初我在我的对象类中有我的枚举和一个将它们作为数组返回的函数:

class someClass: Mappable {

enum Type: Int {
    case A = 0
    case B = 1
    case C = 2
        }
    }
}

func getAllTypes() -> [Type] {
    return [Type.A, Type.B, Type.C]
}
}

我想从我的对象类中提取它的原因是因为这种类型也在其他类中使用，我不想复制任何不必要的代码。

我可以设法对枚举进行子类化，但不能对返回数组中所有类型的函数进行子类化。

我们将不胜感激。

Answer 1

使用只执行一次的闭包和AnyGenerator

初始化all

@vacawama展示了如何使用仅执行一次的闭包结合 的可失败 init(rawValue:) 初始值设定项以通用方式初始化 all 数组枚举的。上述答案中方法的一个细微变化是交换显式 while 循环和附加 AnyGenerator 的数组:

enum Type: Int {
    case A = 0, B, C, D, E, F, G, H

    static let all: [Type] = {
        var rValue = 0
        return AnyGenerator<Type> {
            defer { rValue += 1 }
            return Type(rawValue: rValue)
        }.map{$0}
    }()
}

print(Type.all) 
    // [Type.A, Type.B, Type.C, Type.D, Type.E, Type.F, Type.G, Type.H]

这在 rawValue 只是 ++ 递增(0, 1, 2, ...)的情况下有效。

---

通过使enum符合SequenceType来初始化all

作为另一种选择，由于您的 rawValue 是整数顺序的 (++)，您可以让您的 enum 符合SequenceType，在这种情况下，只需使用 .map

即可轻松生成所有案例的数组

enum Type: Int, SequenceType {
    case A = 0, B, C, D, E, F, G, H
    
    init() { self = A } // Default (first) case intializer
    
    /* conform Type to SequenceType (here: enables only 
       simple (self.rawValue)...last traversing) */
    func generate() -> AnyGenerator<Type> {
        var rValue = self.rawValue
        return AnyGenerator {
            defer { rValue += 1 }
            return Type(rawValue: rValue)
        }
    }
    
    /* use the fact that Type conforms to SequenceType to neatly
     initialize your static all array */
     static let all = Type().map { $0 }
}

print(Type.all) 
    // [Type.A, Type.B, Type.C, Type.D, Type.E, Type.F, Type.G, Type.H]

应用此一致性仅来初始化静态all数组可能有点矫枉过正，但如果您希望能够使用其他方面，这是一个合理的选择您的 enum 符合 SequenceType

for typeCase in Type() {
    // treat each type ...
    print(typeCase, terminator: " ")
} // A B C D E F G H

for caseFromEAndForward in Type.E {
    print(caseFromEAndForward, terminator: " ")
} // E F G H

---

使用 flatMap 根据 rawValue 的范围初始化案例

最后，作为 @appzYourLife neat solution 的变体，如果你有很多情况，你可以在 rawValue 的范围上使用 flatMap 操作来初始化静态 allValues 数组，例如

enum Type: Int {
    case A = 0, B, C, D, E, F, G, H
    static let all = (A.rawValue...H.rawValue)
       .flatMap{ Type(rawValue: $0) }
}

print(Type.all) 
    // [Type.A, Type.B, Type.C, Type.D, Type.E, Type.F, Type.G, Type.H]

然而，这种方法实际上并没有任何实际用途，因为一般大小方法(@vacawama:s 或上面的 SequenceType)对于许多情况下的枚举总是更可取。我可以看到的可能用例是，如果不同情况的 rawValue 是连续的 ，而不是简单地按 ++，例如如果 rawValue 用于某些位掩码

// ...
case A = 0, B = 2, C = 4, D = 8, E = 16, F = 32, G = 64, H = 128

上述方法将使用一种通过 rawValue 范围的强制方法，其中少数实际上对应于实际情况。有点浪费，但由于它是一次性静态初始化，所以这应该不是问题。