How to retrieve results from Struct in array - swift

Question

I have an enum and Struct that looks like the following.
enum Position: String {
case lw = "Left Wing"
case rw = "Right Wing"
case c = "Centre"
case d = "Defense"
case g = "Goalie"
}
struct PlayerInformation {
let firstName: String
let lastName: String
let position: Position
let number: Int
}
struct ShiftDetails {
let player: PlayerInformation
var timeOnIce: Int
var dateOnIce: Date
}
I build the playerInformationArray with the following:
var playerInformationArray = [PlayerInformation]()
let sidneyCrosby = PlayerInformation.init(firstName: "Sidney", lastName: "Crosby", position: Position.c, number: 87)
let alexOvechkin = PlayerInformation.init(firstName: "Alex", lastName: "Ovechkin", position: Position.lw, number: 8)
let patrickKane = PlayerInformation.init(firstName: "Patrick", lastName: "Kane", position: Position.rw, number: 88)
playerInformationArray.append(sidneyCrosby)
playerInformationArray.append(alexOvechkin)
playerInformationArray.append(patrickKane)
I store information about a players "shift" in the following array:
var shiftDetails = [ShiftDetails]()
I retrieve the information about the "selected" player from a collection view with the following:
let selectedPlayer = playerInformationArray[indexPath.row]
I then update the shiftDetails array with the following:
shiftDetails.append( ShiftDetails.init(player: selectedPlayer, timeOnIce: timerCounter, dateOnIce: Date()) )
Everything works as excepted, but I'm having a hard time understanding, how to retrieve data from the arrays. For example:
How would I retrieve the count of shiftDetails per player?
How would I retrieve the sum of timeOnIce per player?
Thanks!

Answer 1

If you need to check if certain player is equal to another player you need to make it conform to Equatable protocol implementing the double equal operator ==. You can also make your struct conform to `CustomStringConvertible and provide a custom description to it:
struct Player: Equatable, CustomStringConvertible {
let firstName: String
let lastName: String
let position: Position
let number: Int
static func ==(lhs: Player, rhs: Player) -> Bool {
return lhs.firstName == rhs.firstName && lhs.lastName == rhs.lastName
}
var description: String {
return "Player: " + firstName + " " + lastName
}
}
Also in Swift you should always prefer long names (camelCase) for better readability and try to avoid redundant information when naming your properties and you shouldn't add the type to your object names:
enum Position: String {
case leftWing = "Left Wing"
case rightWing = "Right Wing"
case center = "Center"
case defense = "Defense"
case golie = "Goalie"
}
struct Shift {
let player: Player
var timeOnIce: Int
var dateOnIce: Date
}
var players: [Player] = []
let sidneyCrosby = Player(firstName: "Sidney", lastName: "Crosby", position: .center, number: 87)
let alexOvechkin = Player(firstName: "Alex", lastName: "Ovechkin", position: .leftWing, number: 8)
let patrickKane = Player(firstName: "Patrick", lastName: "Kane", position: .rightWing, number: 88)
players += [sidneyCrosby, alexOvechkin, patrickKane]
var shifts: [Shift] = []
var index = IndexPath(row: 0, section: 0)
var selectedPlayer = players[index.row]
let shift1 = Shift(player: selectedPlayer, timeOnIce: 3, dateOnIce: Date())
shifts.append(shift1)
let shift2 = Shift(player: selectedPlayer, timeOnIce: 5, dateOnIce: Date())
shifts.append(shift2)
To sum timeOnIce property per player and its count, you could extend Array constraining the elements to Shift type:
extension Array where Element == Shift {
func timeOnIceAndCount(for player: Player) -> (timeOnIce: Int, count: Int) {
return reduce((0,0)) {
$1.player == player ? ($0.0 + $1.timeOnIce, $0.1 + 1) : $0
}
}
}
let (timeOnIce, count) = shifts.timeOnIceAndCount(for: selectedPlayer)
print(selectedPlayer)
print("TimeOnIce:",timeOnIce)
print("Count: ", count)
This will print
Player: Sidney Crosby
TimeOnIce: 8
Count: 2

Answer 2

This may not end up being the cleanest way of doing this since all your shiftDetails are held in a single, shared array, but in order to accomplish this with your current setup you could use the built-in filter function to get information about a given player. This could look something like this:
let selectedPlayer = playerInformationArray[indexPath.row]
let filteredDetails = shiftDetails.filter({ $0.player == selectedPlayer })
let shiftCount = filteredDetails.count
let timeOnIce = filteredDetails.reduce(0, { $0 + $1.timeOnIce })
Another option would be to maintain a shiftDetails array for each player, at which point you don't need to do any filtering. Or, another option would be to have the shiftDetails be a dictionary where the key is the player and the value is an array of shiftDetails.
It is also worth noting that my example of the filter function assumes your Player struct conforms to the Equatable protocol - in other words, that you can legally say playerOne == playerTwo. If you don't do this you would have to match on some other unique field such as name or playerId or something like that.