Nrthugu

I am implementing a UITableView which will have multiple sections. The amount of sections are dynamic. This are some properties:

public struct User { 

    let userRole: UserRole

}



public enum UserRole: Int, CaseIterable { 

    case superUser, admin, recruiter

}

My UITableView holds an array of users. The amount of sections are the amount of distinct userRoles in the array of users. Later on, I need to determine how many rows there are in each section with this function:

public func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {}

I am wondering what the most clean/fastest way is to return the amount of rows in that section. Imagine the user array holds 2 users, one has a userRole of superUser and the other recruiter. The sections are 0 and 1, although the enum raw values are 0 and 2.

I have no idea how to return the correct amount of rows in that section in a clean way. This is what I was writing, but stopped since I though there must be a better way:

extension Array where Element: User {

    func contains(userRole: UserRole) -> Bool {

        return contains(where: { $0.userRole == userRole })

    }

}



private func determineUserRoleForSection(section: Int) -> UserRole {

    let containsSuperUser = users.contains(userRole: .superUser)

    let containsAdmin = users.contains(userRole: .admin)

    let containsRecruiter = users.contains(userRole: .recruiter)



    switch section {

    case 0:

        if containsSuperUser {

            return .superUser

        }



        if containsAdmin {

            return .admin

        }



        if containsRecruiter {

            return .recruiter

        }

    case 1:

        // Repeat without superUser case

    case 2:

    default: fatalError()

    }

}

Following the recommendation of having a model, you could do something like this:

public struct UsersViewModel {

    var users: [User]

    private var sections: [UserRole: [User]] {

        return [

            .admin : users.filter { $0.userRole == .admin },

            .superUser : users.filter { $0.userRole == .superUser },

            .recruiter : users.filter { $0.userRole == .recruiter }

        ]

    }

    var superUserSections: Int { return sections[.superUser]!.count}

    var adminSections: Int { return sections[.admin]!.count }

    var recruiterSections: Int { return sections[.recruiter]!.count }

}

And then it'd just be a matter of using:

public func tableView(_ tableView: UITableView, numberOfSections section: Int) -> Int {

    return 3 // section 0 is superUser, section 1 is admin, section 2 is recruiter.

}



public func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {

    switch section {

    case 0:

        return viewModel.superUserSections

    case 1:

        return viewModel.adminSections

    case 2:

        return viewModel.recruiterSections

    }   

}