Using YapDatabase Views & Mappings with Swift

persistent_datasource.swift

extension YapDatabaseView {

    public enum Grouping {

        case ByKey(YapDatabaseViewGroupingWithKeyBlock)
        case ByObject(YapDatabaseViewGroupingWithObjectBlock)
        case ByMetadata(YapDatabaseViewGroupingWithMetadataBlock)
        case ByRow(YapDatabaseViewGroupingWithRowBlock)

        var object: YapDatabaseViewGrouping {
            get {
                switch self {
                case .ByKey(let block):
                    return YapDatabaseViewGrouping.withKeyBlock(block)
                case .ByObject(let block):
                    return YapDatabaseViewGrouping.withObjectBlock(block)
                case .ByMetadata(let block):
                    return YapDatabaseViewGrouping.withMetadataBlock(block)
                case .ByRow(let block):
                    return YapDatabaseViewGrouping.withRowBlock(block)
                }
            }
        }
    }

    public enum Sorting {

        case ByKey(YapDatabaseViewSortingWithKeyBlock)
        case ByObject(YapDatabaseViewSortingWithObjectBlock)
        case ByMetadata(YapDatabaseViewSortingWithMetadataBlock)
        case ByRow(YapDatabaseViewSortingWithRowBlock)

        var object: YapDatabaseViewSorting {
            get {
                switch self {
                case .ByKey(let block):
                    return YapDatabaseViewSorting.withKeyBlock(block)
                case .ByObject(let block):
                    return YapDatabaseViewSorting.withObjectBlock(block)
                case .ByMetadata(let block):
                    return YapDatabaseViewSorting.withMetadataBlock(block)
                case .ByRow(let block):
                    return YapDatabaseViewSorting.withRowBlock(block)
                }
            }
        }
    }
}

extension YapDatabaseViewMappings {

    typealias DisplayChangeSet = (sections: [YapDatabaseViewSectionChange], items: [YapDatabaseViewRowChange])

    class func passThroughFilter() -> YapDatabaseViewMappingGroupFilter {
        return { (group, transaction) -> Bool in
            return true
        }
    }
    class func defaultSorter() -> YapDatabaseViewMappingGroupSort {
        return { (group1, group2, transaction) -> NSComparisonResult in
            return group1.caseInsensitiveCompare(group2)
        }
    }
}

public class PersistedDataSource: NSObject {

    typealias GroupFilter = YapDatabaseViewMappingGroupFilter
    typealias GroupSorter = YapDatabaseViewMappingGroupSort

    let name: String
    let database: YapDatabase
    let view: YapDatabaseView
    let mappings: YapDatabaseViewMappings
    let readOnlyConnection: YapDatabaseConnection

    init(name _name: String, database _database: YapDatabase, grouping: YapDatabaseView.Grouping, sorting: YapDatabaseView.Sorting, filter: GroupFilter = YapDatabaseViewMappings.passThroughFilter(), sorter: GroupSorter = YapDatabaseViewMappings.defaultSorter()) {
        name = _name
        database = _database
        view = YapDatabaseView(grouping: grouping.object, sorting: sorting.object)
        database.registerExtension(view, withName: name)

        readOnlyConnection = database.newConnection()
        mappings = YapDatabaseViewMappings(groupFilterBlock: filter, sortBlock: sorter, view: name)
        super.init()
        readOnlyConnection.beginLongLivedReadTransaction()
        readOnlyConnection.readWithBlock { [weak self] (transaction) -> Void in
            self!.mappings.updateWithTransaction(transaction)
        }
    }

    // Implement UICollectionViewDataSource and UITableViewDataSource in extensions or whatever.
}


let grouping: YapDatabaseView.Grouping = .ByObject({ (collection, key, object) -> String! in
    return (collection == Participant.collectionName()) ? "Contacts" : nil
})

let sorting: YapDatabaseView.Sorting = .ByObject({ (group, collection1, key1, object1, collection2, key2, object2) -> NSComparisonResult in
    return .OrderedAscending
})

dataSource = PersistedDataSource<Participant>(name: name, database: database, grouping:grouping, sorting:sorting)