Elegant serialization/deserialization of enum with associated values - swift

Question

I would like to use enum with associated values for type-safe NSNotifications:
enum Notification {
case Foo(Int)
case Bar
var rawValue: String {
switch self {
case .Foo:
return "Foo"
case .Bar:
return "Bar"
}
}
var asNSNotification: NSNotification {
let userInfo = [String: AnyObject]()
switch self {
case let .Foo(intVal):
userInfo["intVal": intVal]
default:
break
}
return NSNotification(name: rawValue, object: nil, userInfo: userInfo)
}
init?(fromNSNotification n: NSNotification) {
switch n.name {
case .Bar:
self = .Bar
case .Foo(42): // some bogus value
let realValue = n.userInfo?["intVal"] ?? 0
self = .Foo(realValue)
default:
return nil
}
}
}
This should work, but it sure is an ugly piece of code. Anyone has ideas how to make it more elegant?
EDIT: the reason why I want to use enum is to make parameters of each notification type-safe.
By "more elegant" I mean:
Simplify rawValue property (avoid having to switch)
Avoid "bogus values" when referencing enum cases with associated values in
initializer.
Anything that would reduce verbosity and improve
readability.
Okay, here's how rawValue property can be simplified:
var rawValue: String {
return Mirror(reflecting: self).children.first.flatMap({ $0.label }) ?? "\(self)"
}

Answer 1

It seems to me that your enum is working too hard. This should be sufficient:
enum Notification {
case Foo(Int)
case Bar
func notification() -> NSNotification {
switch self {
case Foo(let intVal):
return NSNotification(name: "Foo", object: nil, userInfo: ["IntVal":intVal])
case Bar:
return NSNotification(name: "Bar", object: nil)
}
}
}
Adding the ability to supply a non-nil object is left as an exercise for the reader.

Answer 2

I think I have figured out how to make the handling of NSNotifications more elegant:
enum NotificationType: String {
case Foo
case Bar
}
enum Notification {
case Foo(Int)
case Bar
// the fragile part
var type: NotificationType {
let name = Mirror(reflecting: self).children.first.flatMap({ $0.label }) ?? "\(self)"
return NotificationType(rawValue: name)!
}
var asNSNotification: NSNotification {
let name = type.rawValue
let userInfo = [String: AnyObject]()
switch self {
case let .Foo(intVal):
userInfo["intVal": intVal]
default:
break
}
return NSNotification(name: name, object: nil, userInfo: userInfo)
}
init?(fromNSNotification n: NSNotification) {
let type = NotificationType(rawValue: n.name)!
switch type {
case .Bar:
self = .Bar
case .Foo:
let value = n.userInfo?["intVal"] ?? 0
self = .Foo(value)
default:
return nil
}
}
}
This solution relies on the convention that case names in Notification and NotificationType are the same. One might say that such design is fragile, but I think this is little tradeoff compared to what we achieve.
Below is a little helper class to handle subscription/unsubscription:
protocol NotificationReceiving: class {
func didReceiveNotification(notification: Notification)
}
class NotificationReceiver {
private weak var delegate: NotificationReceiving?
private(set) var subscriptions = Set<NotificationType>()
init(delegate: NotificationReceiving?) {
self.delegate = delegate
}
func subscribe(notificationTypes: NotificationType...) {
let nc = NSNotificationCenter.defaultCenter()
let doSubscribe: NotificationType -> Void = {
nc.addObserver(self, selector: "handleNotification:", name: $0.name, object: nil)
self.subscriptions.insert($0)
}
notificationTypes.forEach(doSubscribe)
}
func unsubscribe(notificationTypes: NotificationType...) {
let nc = NSNotificationCenter.defaultCenter()
if notificationTypes.isEmpty {
nc.removeObserver(self)
} else {
let doUnsubscribe: NotificationType -> Void = {
nc.removeObserver(self, name: $0.name, object: nil)
self.subscriptions.remove($0)
}
notificationTypes.forEach(doUnsubscribe)
}
}
#objc private func handleNotification(notification: NSNotification) {
if let n = Notification(fromNSNotification: notification) {
delegate?.didReceiveNotification(n)
}
}
}
This is how a client might look:
class Client: NotificationReceiving {
private var receiver: NotificationReceiver!
init() {
receiver = NotificationReceiver(delegate: self)
receiver.subscribe(.Foo, .Bar)
}
deinit {
receiver.unsubscribe()
}
func didReceiveNotification(notification: Notification) {
switch notification {
case let .Foo(val):
print("foo with val: \(val)")
// this notification is one-shot:
receiver.unsubscribe(.Foo)
case .Bar:
print("bar!")
}
}
}
Not sure handling all notifications in one method is good design (I guess it might get messy when there are many notifications), but the point is that we can now use the power of type safety and pattern matching, which is awesome.