在Swift中声明并使用位字段枚举

Posted 2021-04-01

如何在Swift中声明和使用位字段？

声明这样的枚举确实有效，但尝试将OR 2值一起编译失败：

enum MyEnum: Int
{
    case One =      0x01
    case Two =      0x02
    case Four =     0x04
    case Eight =    0x08
}

// This works as expected
let m1: MyEnum = .One

// Compiler error: "Could not find an overload for '|' that accepts the supplied arguments"
let combined: MyEnum = MyEnum.One | MyEnum.Four

我查看了Swift如何导入Foundation枚举类型，并通过定义符合struct协议的RawOptionSet来实现：

struct NSCalendarUnit : RawOptionSet {
    init(_ value: UInt)
    var value: UInt
    static var CalendarUnitEra: NSCalendarUnit { get }
    static var CalendarUnitYear: NSCalendarUnit { get }
    // ...
}

而RawOptionSet协议是：

protocol RawOptionSet : LogicValue, Equatable {
    class func fromMask(raw: Self.RawType) -> Self
}

但是，没有关于此协议的文档，我无法弄清楚如何自己实现它。此外，目前尚不清楚这是否是Swift实现位域的官方方式，或者这只是Objective-C桥接器如何表示它们。

答案

您可以构建符合struct协议的RawOptionSet，并且您将能够像内置的enum类型一样使用它，但也具有位掩码功能。这里的答案显示了：Swift NS_OPTIONS-style bitmask enumerations。

另一答案

我使用以下内容我需要我可以得到的两个值，rawValue用于索引数组和value for flags。

enum MyEnum: Int {
    case one
    case two
    case four
    case eight

    var value: UInt8 {
        return UInt8(1 << self.rawValue)
    }
}

let flags: UInt8 = MyEnum.one.value ^ MyEnum.eight.value

(flags & MyEnum.eight.value) > 0 // true
(flags & MyEnum.four.value) > 0  // false
(flags & MyEnum.two.value) > 0   // false
(flags & MyEnum.one.value) > 0   // true

MyEnum.eight.rawValue // 3
MyEnum.four.rawValue // 2

另一答案

使用原始值进行按位操作，然后使用结果创建新的枚举对象。

let mask = UIViewAutoresizing(rawValue: UIViewAutoresizing.FlexibleWidth.rawValue|UIViewAutoresizing.FlexibleHeight.rawValue) self.view.autoresizingMask = mask

另一答案

这是我放在一起尝试制作一个类似于C＃flags-style枚举的Swift枚举的东西。但我只是学习Swift，所以这只应被视为“概念证明”代码。

/// This EnumBitFlags protocol can be applied to a Swift enum definition, providing a small amount
/// of compatibility with the flags-style enums available in C#.
///
/// The enum should be defined as based on UInt, and enum values should be defined that are powers
/// of two (1, 2, 4, 8, ...). The value zero, if defined, should only be used to indicate a lack of
/// data or an error situation.
///
/// Note that with C# the enum may contain a value that does not correspond to the defined enum
/// constants. This is not possible with Swift, it enforces that only valid values can be set.
public protocol EnumBitFlags : RawRepresentable, BitwiseOperations {

   var rawValue : UInt { get }  // This provided automatically by enum

   static func createNew(_ rawValue : UInt) -> Self  // Must be defined as some boiler-plate code
}

/// Extension methods for enums that implement the EnumBitFlags protocol.
public extension EnumBitFlags {

   // Implement protocol BitwiseOperations. But note that some of these operators, especially ~, 
   // will almost certainly result in an invalid (nil) enum object, resulting in a crash.

   public static func & (leftSide: Self, rightSide: Self) -> Self {
      return self.createNew(leftSide.rawValue & rightSide.rawValue)
   }

   public static func | (leftSide: Self, rightSide: Self) -> Self {
      return self.createNew(leftSide.rawValue | rightSide.rawValue)
   }

   public static func ^ (leftSide: Self, rightSide: Self) -> Self {
      return self.createNew(leftSide.rawValue ^ rightSide.rawValue)
   }

   public static prefix func ~ (x: Self) -> Self {
      return self.createNew(~x.rawValue)
   }

   public static var allZeros: Self {
      get {
         return self.createNew(0)
      }
   }

   // Method hasFlag() for compatibility with C#
   func hasFlag<T : EnumBitFlags>(_ flagToTest : T) -> Bool {
      return (self.rawValue & flagToTest.rawValue) != 0
   }
}

这显示了如何使用它：

class TestEnumBitFlags {

   // Flags-style enum specifying where to write the log messages
   public enum LogDestination : UInt, EnumBitFlags {
      case none = 0             // Error condition
      case systemOutput = 0b01  // Logging messages written to system output file
      case sdCard       = 0b10  // Logging messages written to SD card (or similar storage)
      case both         = 0b11  // Both of the above options

      // Implement EnumBitFlags protocol
      public static func createNew(_ rawValue : UInt) -> LogDestination {
         return LogDestination(rawValue: rawValue)!
      }
   }

   private var _logDestination : LogDestination = .none
   private var _anotherEnum : LogDestination = .none

   func doTest() {

      _logDestination = .systemOutput
      assert(_logDestination.hasFlag(LogDestination.systemOutput))
      assert(!_logDestination.hasFlag(LogDestination.sdCard))

      _anotherEnum = _logDestination
      assert(_logDestination == _anotherEnum)

      _logDestination = .systemOutput | .sdCard
      assert(_logDestination.hasFlag(LogDestination.systemOutput) &&
             _logDestination.hasFlag(LogDestination.sdCard))

      /* don't do this, it results in a crash
      _logDestination = _logDestination & ~.systemOutput
      assert(_logDestination == .sdCard)
      */

      _logDestination = .sdCard
      _logDestination |= .systemOutput
      assert(_logDestination == .both)
   }
}

欢迎提出改进建议。

编辑：我自己已经放弃了这项技术，因此显然不能再推荐它了。

最大的问题是Swift要求rawValue必须匹配其中一个定义的枚举值。如果只有2个或3个甚至4个标志位，这是可以的 - 只需定义所有组合值，以使Swift满意。但是对于5个或更多的标志位，它变得非常疯狂。

如果有人发现它有用，我会留下这个，或者作为不怎么做的警告。

我目前解决这种情况的方法是基于使用struct而不是enum，以及协议和一些扩展方法。这样做效果更好。也许有一天我会发布它，当我更确定那不是也不会适得其反。

另一答案

这对我有用。

• 1 << 0 //0000
• 1 << 1 //0010
• 1 << 2 //0100
• << 1 3 // 1000 enum Collision: Int { case Enemy, Projectile, Debris, Ground func bitmask() -> UInt32 { return 1 << self.rawValue } }

另一答案

他们在其中一个WWDC视频中展示了如何做到这一点。

let combined = MyEnum.One.toRaw() | MyEnum.Four.toRaw()

请注意，combined将是Int类型，如果指定let combined: MyEnum，实际上会出现编译器错误。那是因为0x05没有枚举值，这是表达式的结果。

另一答案

更新了Swift 2/3

从swift 2开始，新的解决方案被添加为“原始选项集”（see: Documentation），它与我的原始响应基本相同，但使用允许任意值的结构。

这是重写为OptionSet的原始问题：

struct MyOptions: OptionSet
{
    let rawValue: UInt8

    static let One = MyOptions(rawValue: 0x01)
    static let Two = MyOptions(rawValue: 0x02)
    static let Four = MyOptions(rawValue: 0x04)
    static let Eight = MyOptions(rawValue: 0x08)
}

let m1 : MyOptions = .One

let combined : MyOptions = [MyOptions.One, MyOptions.Four]

结合新值可以完全像Set操作（因此OptionSet部分），.union，同样：

m1.union(.Four).rawValue // Produces 5

与在C-equivalent中做One | Four相同。至于One & Mask != 0，可以指定为非空交集

// Equivalent of A & B != 0
if !m1.intersection(combined).isEmpty
{
    // m1 belongs is in combined
}

奇怪的是，大多数C风格的按位枚举已经转换为他们在Swift 3上的OptionSet等价物，但Calendar.Compontents消除了Set<Enum>：

let compontentKeys : Set<Calendar.Component> = [.day, .month, .year]

而原始的NSCalendarUnit是一个按位枚举。所以这两种方法都是可用的（因此原始响应仍然有效）

原始回应

我认为最好的办法是简单地避免使用bitmask语法，直到Swift开发人员找到更好的方法。

大多数时候，使用enum和Set可以解决问题

enum Options
{
    case A, B, C, D
}

var options = Set<Options>(arrayLiteral: .A, .D)

An和check（options & .A）可以定义为：

options.contains(.A)

或者对于多个“标志”可以是：

options.isSupersetOf(Set<Options>(arrayLiteral: .A, .D))

添加新标志（options |= .C）：

options.insert(.C)

这也允许使用枚举的所有新东西：自定义类型，与开关盒的模式匹配等。

当然，它没有按位操作的效率，也不兼容低级别的东西（比如发送蓝牙命令），但它对UI元素的用处是UI的开销超过了Set操作的成本。

另一答案

我想也许这里的一些答案已经过时了，过于复杂的解决方案？这对我来说很好..

enum MyEnum: Int  {

    case One = 0
    case Two = 1
    case Three = 2
    case Four = 4
    case Five = 8
    case Six = 16

}

let enumCombined = MyEnum.Five.rawValue | MyEnum.Six.rawValue

if enumCo
以上是关于在Swift中声明并使用位字段枚举的主要内容，如果未能解决你的问题，请参考以下文章
 
 Swift函数式编程七（枚举）
 如何在 Swift 中为 SpriteKit 定义类别位掩码枚举？
 声明枚举路由器 Alamofire swift 3.0
 NestJS Swagger - 如何声明多选枚举字段？
 Swift新async/await并发中利用Task防止指定代码片段执行的数据竞争(Data Race)问题
 Swift新async/await并发中利用Task防止指定代码片段执行的数据竞争(Data Race)问题