Tag: RawRepresentable

Let’s build a container where we can store collections of items conforming to a protocol. All the collections are identified by a case in enum. For making the container reusable, we’ll use protocols as requirements on keys and items in collections. Moreover, the container should be archivable and unarchivable.

Creating a reusable container

Container’s implementation wraps a dictionary and adds methods for conveniently adding an item for key. Key must implement Hashable and RawRepresentable: then it can be used in Dictionary and converting it to representation suitable for storing on disk.

Every item needs to implement ContainerItem protocol what requires to implement methods used when archiving and unarchiving the item. Thanks to Codable protocol in Swift, it is very simple to transform the item to data and back. ContainerItem provides default implementations for its own methods when the type is conforming to Codable. Therefore, when some type wants to implement ContainerItem, then it only needs to conform to ContainerItem and Codable and default implementations will do the rest.

	final class Container<Key: Hashable & RawRepresentable> {
	private var storage = [Key: [ContainerItem]]() {
	didSet {
	didChange()
	}
	}
	init(content: [Key: [ContainerItem]] = [:]) {
	storage = content
	}
	func add(_ item: ContainerItem, key: Key) {
	if var current = storage[key] {
	current.append(item)
	storage[key] = current
	}
	else {
	storage[key] = [item]
	}
	}
	func items<T: ContainerItem>(forKey key: Key) -> [T] {
	guard let all = storage[key] else { return [] }
	return all as! [T]
	}
	var didChange: () -> Void = {}
	}
	protocol ContainerItem {
	init?(jsonData: Data)
	var jsonDataRepresentation: Data { get }
	}
	extension ContainerItem where Self: Codable {
	init?(jsonData: Data) {
	guard let object = try? JSONDecoder().decode(Self.self, from: jsonData) else { return nil }
	self = object
	}
	var jsonDataRepresentation: Data {
	return try! JSONEncoder().encode(self)
	}
	}

view raw PersistentReusableContainer.swift hosted with ❤ by GitHub

Archiving and unarchiving the container and it’s content

Let’s first extend the container with write method. As enum cases are used as keys in dictionary, then let’s implement write method for enums what have String as RawValue. (what should be a preferred way in this use case as its provides the most readable representation of the key). We can then map dictionary entries so that key is converted to String and value to array of JSON data objects. NSKeyedArchiver provides a simple way of storing Dictionary with archivable types (like String and array of Data).

For initialising the container from data on disk, we need to make sure that we convert JSON data back to the correct type. Therefore we can extend the container for this specific enum case and converting data back to the correct type. When using enums it is easy to switch over the possible cases and then converting list of data objects to list of known types.

	struct EventItem: ContainerItem, Codable {
	let date: Date
	let title: String
	let description: String
	}
	struct NoteItem: ContainerItem, Codable {
	let text: String
	}
	enum CalendarKeys: String {
	case homeEvents, workEvents, notes
	}
	extension Container where Key == CalendarKeys {
	convenience init(contentsOfURL url: URL) throws {
	let data = try Data(contentsOf: url)
	let contents = try NSKeyedUnarchiver.unarchiveTopLevelObjectWithData(data) as! [Key.RawValue: [Data]]
	let converted = contents.compactMap({ (keyValuePair) -> (Key, [ContainerItem])? in
	guard let key = Key(rawValue: keyValuePair.key) else { return nil }
	switch key {
	case .homeEvents, .workEvents:
	return (key, keyValuePair.value.compactMap({ EventItem(jsonData: $0) }))
	case .notes:
	return (key, keyValuePair.value.compactMap({ NoteItem(jsonData: $0) }))
	}
	})
	self.init(content: Dictionary(uniqueKeysWithValues: converted))
	}
	}
	extension Container where Key.RawValue == String {
	func write(to url: URL) throws {
	let converted = storage.map { (keyValuePair) -> (String, [Data]) in
	return (keyValuePair.key.rawValue, keyValuePair.value.map({ $0.jsonDataRepresentation }))
	}
	let data = try NSKeyedArchiver.archivedData(withRootObject: Dictionary(uniqueKeysWithValues: converted), requiringSecureCoding: false)
	try data.write(to: url, options: .atomicWrite)
	}
	}

view raw PersistentReusableContainer.swift hosted with ❤ by GitHub

Summary

Wrapping dictionary with another type can be useful inmany cases where we have a known list of keys. Specialising generic types is an efficient way of adding more features to it and keeping type information intact. Thanks to Codable protocol we were able to make types archivable and unarchivable.

	let container = Container<CalendarKeys>()
	let event1 = EventItem(date: Date(), title: "title1", description: "description1")
	container.add(event1, key: .homeEvents)
	let event2 = EventItem(date: Date(), title: "title2", description: "description2")
	container.add(event2, key: .workEvents)
	let note1 = NoteItem(text: "text3")
	container.add(note1, key: .notes)
	let homeEvents: [EventItem] = container.items(forKey: .homeEvents)
	let workEvents: [EventItem] = container.items(forKey: .workEvents)
	let notes: [NoteItem] = container.items(forKey: .notes)
	let url = URL(fileURLWithPath: NSTemporaryDirectory()).appendingPathComponent("Test")
	do {
	try container.write(to: url)
	}
	catch {
	print(error as NSError)
	}
	do {
	let restoredContainer = try Container<CalendarKeys>(contentsOfURL: url)
	let homeEvents: [EventItem] = restoredContainer.items(forKey: .homeEvents)
	let workEvents: [EventItem] = restoredContainer.items(forKey: .workEvents)
	let notes: [NoteItem] = restoredContainer.items(forKey: .notes)
	print("Home events: ", homeEvents)
	print("Work events: ", workEvents)
	print("Notes: ", notes)
	}
	catch {
	print(error as NSError)
	}

view raw PersistentReusableContainer.swift hosted with ❤ by GitHub

If this was helpful, please let me know on Mastodon@toomasvahter or Twitter @toomasvahter. Feel free to subscribe to RSS feed. Thank you for reading.

Example

PersistentGenericContainer (Xcode 11.1)