How do I sort Swift objects by multiple criteria - sorting

Question

I have a list of Swift objects that I'd like to get sorted by multiple criteria. The objects in the list are of type DateRange:
class DateRange {
var from: NSDate?
var to: NSDate?
}
The list contains many of these objects where some from or to fields are nil. I want to have this list sorted by:
First all objects that have dates
Then objects that have at least one date (either from or to)
And at the very end objects without any
The dates itself don't matter, just their existence. In Ruby I could do this (if the date is nil I set it to a very low date):
date_ranges.sort { |a, b|
[fix_nil(a.from), fix_nil(a.to)] <=> [fix_nil(b.from), fix_nil(b.to)]
}.reverse
def fix_nil(val)
val.nil? ? Date.new(0) : val
end
What's the best way to do this with Swift? Thanks in advance.

Answer 1

Seems like it might be a good idea to add a dateCount computed property to your DateRange type. This would be a good time for pattern matching:
extension DateRange {
// returns the number of non-nil NSDate members in 'from' and 'to'
var dateCount: Int {
switch (from, to) {
case (nil, nil): return 0
case (nil, _): return 1
case (_, nil): return 1
default: return 2
}
}
}
Then you can sort your list with a simple closure:
var ranges = [DateRange(nil, nil), DateRange(NSDate(), nil), DateRange(nil, NSDate()), DateRange(nil, nil), DateRange(NSDate(), NSDate())]
ranges.sort { $0.dateCount > $1.dateCount }
If you wanted, you could even make it Comparable with a few more lines:
extension DateRange : Comparable { }
func ==(lhs: DateRange, rhs: DateRange) -> Bool {
return lhs.dateCount == rhs.dateCount
}
func <(lhs: DateRange, rhs: DateRange) -> Bool {
return lhs.dateCount > rhs.dateCount
}
This lets you sort your list properly with an operator argument:
ranges.sort(<)

Answer 2

I presume that by list you mean array, so I am basing my answer on that assumption.
You can use the sort method of the array struct, which takes a closure having this signature:
(lhs: T, rhs: T) -> Bool
returning true if lhs is less than rhs, false otherwise.
I came up with this implementation:
var x: [DateRange]
// ... initialize the array
x.sort { (lhs: DateRange, rhs: DateRange) -> Bool in
if lhs.from != nil && lhs.to != nil {
return true
}
if lhs.from == nil && lhs.to == nil {
return false
}
return rhs.from == nil && rhs.to == nil
}
if lhs has both properties not nil, then it comes first, regardless of rhs
if lhs has both properties nil, then if comes after, regardless of rhs
else lhs has one nil, the other not nil, and in that case it comes first only if rhs has both properties nil
If you plan to reuse the sort in several places, it's better to move the code out of the sort method - the best place is probably an overload of the < operator:
func < (lhs: DateRange, rhs: DateRange) -> Bool {
if lhs.from != nil && lhs.to != nil {
return true
}
if lhs.from == nil && lhs.to == nil {
return false
}
return rhs.from == nil && rhs.to == nil
}
and in that case it can be used as follows:
x.sort(<)
If you don't like the operator overload, you can of course give that function any other name.
Note that sorting is done in place.

Answer 3

Here is how I would approach this. To keep things simple, add a scoring function for the date range. In your scenario, you have 3 possibilities:
nil & nil : 0 points
nil & date : 1 point
date & date : 2 points
import Foundation
class DateRange {
var from: NSDate?
var to: NSDate?
init(from: NSDate?, to: NSDate?)
{
self.from = from
self.to = to
}
func scoreDateRange() -> Int
{
var score = 0
if from != nil
{
score++
}
if to != nil
{
score++
}
return score
}
}
func sortDateRange( d1 : DateRange, d2 : DateRange)-> Bool
{
return d1.scoreDateRange() > d2.scoreDateRange()
}
var date_ranges = [DateRange]()
date_ranges.append(DateRange(from:nil, to:nil))
date_ranges.append(DateRange(from:nil, to:nil))
date_ranges.append(DateRange(from:NSDate(), to:NSDate()))
date_ranges.append(DateRange(from:nil, to:NSDate()))
date_ranges.append(DateRange(from:NSDate(), to:nil))
date_ranges.append(DateRange(from:NSDate(), to:NSDate()))
date_ranges.sort(sortDateRange)