Swift协议：RawRepresentable

enum 中的RawRepresentable

RawRepresentable是一个协议，包含关联类型RawValue RawValue相当于一个范型，遵循这个协议相当于该对象拥有了一个“原始值”。我们知道在定义enum时，如果在冒号后面指定一个类型如 Int，则enum拥有了rawValue（原始值），因为它遵循了RawRepresentable协议。
下面定义一个枚举。

    enum User: String {
        case isLogin
        case loginTime
    }

User.isLogin.rawValue 值为字符串”isLogin“，而rawValue能保证在此枚举中是唯一的。
我们可以利用这个特性设计一些需要保证唯一性的功能，而且这能做字符串编译器检查，否则手写字符串会导致拼写错误，代码更加简洁方便。

我们可以将此特性引用于UserDefault中，当需要往UserDefaults存数据时，需要指定key。
先定义一个协议, 该协议userDefaultsKey表示UserDefaults的key

public protocol UserDefaultsAccessable {
    var userDefaultsKey: String { get }
}

然后为UserDefaultsAccessable提供默认实现，并增加几个访问UserDefaults的方法。包括存数据和取数据

public extension UserDefaultsAccessable where Self: RawRepresentable, Self.RawValue == String {
     // 以此为UserDefaults的key
    var userDefaultsKey: String {
        "\(Self.self).\(rawValue)"
    }
    /// 取bool 值
    func boolVal() -> Bool {
        return UserDefaults.standard.bool(forKey: userDefaultsKey)
    }

    /// 存储
    func storeBool(_ value: Bool) {
        return UserDefaults.standard.setValue(value, forKey: userDefaultsKey)
    }
    ///... 下面还可以增加其他类型数据的存取方法
}

where Self: RawRepresentable, Self.RawValue == String 这句话对协议进行限定表示遵循这个协议的对象必须遵循RawRepresentable协议，并且RawValue类型为String。这样就能在协议的默认实现里使用RawRepresentable的rawValue属性，很强大。
这里的是可以利用范型的，如存方法可以改成

    /// 存储
    func store<T: Codable>(_ value: T) {
        ....
    }

遵循了Codable 就可以将对象encode to字符串，然后保存到UserDefaults，取数据时再将其还原。

func _encode<T: Codable>(_ value: T) -> String? {
        do {
            let data = try JSONEncoder().encode([value])
            return String(String(data: data, encoding: .utf8)!.dropFirst().dropLast())
        } catch {
            print(error)
            return nil
        }
    }

使用时定义一个枚举，并遵循UserDefaultsAccessable协议

extension UserDefaults {
    enum User: String, UserDefaultsAccessable {
        case isLogin
        case loginWay
    }
}

外面包一个UserDefaults是一个命名空间，防止与其他类型同名，这样User就拥有存取特性了；可以这样使用：

//存
UserDefaults.User.isLogin.storeBool(true)
//取
UserDefaults.User.isLogin.boolVal()

这样用起来是不是更加简单方便呢，还能保证key的唯一性。

OptionSet 中的RawRepresentable

OptionSet也遵循了RawRepresentable协议，OptionSet都知道类似于c语言的可选枚举，它通过或运算组合多个值；下面定义一个OptionSet类型结构体。

struct Direction: OptionSet {
    let rawValue: Int
    static let left = Direction(rawValue: 1 << 0)
    static let right = Direction(rawValue: 1 << 1)
    static let bottom = Direction(rawValue: 1 << 2)
    static let tp = Direction(rawValue: 1 << 3)
    static let all: Direction = [.left, .right, .bottom, .top]
}

let rawValue: Int是RawRepresentable的协议，必须遵循，如何使用呢？通过contains方法，他是OptionSet的一个默认实现的方法，内部通过位运算判断是否包含某个值

var left: Direction = .left
let right = Direction.right
let left_right = [Direction.left, Direction.right]
let left_right_top: Direction = [.left, [.top, .right]]
let allDir: Direction = .all
left.insert(.bottom)

print(left.contains(.bottom))
print(right.contains(.left))
print(left_right.contains(.left))
print(left_right_top.contains(.top))
print(allDir.contains(.bottom))

这里有一个很奇怪的事情let left_right: Direction = [.left, .right]这句如果改成let left_right = [Direction.left, Direction.right]，则left_right的类型变成了数组，猜测是编译器在进行自动类型转换，如果指定了Direction类型，自动转换成Direction。
还有一种用法，我们可以通过init(rawValue:)进行初始化, 因为它遵循了RawRepresentable的协议。

let dir = Direction(rawValue: 22)

这种初始化方式不会失败，我们知道enum（有原始值）也可以通过这种方式初始化，如上面的enum

let other = UserDefaults.User(rawValue: "other")
print(other)

这种初始化是可能失败的，因为OptionSet没有所有可能情况的枚举列表，而枚举有。选项集值与其关联的原始值有一一对应关系。

print(left_right_top.rawValue)