Swift: Find date in array that is closest in time - swift

Question

This is my first time developing in swift (macOS command line application).
I am iterating over all jpeg files in a folder, take those that don't have GPS info in the EXIF data and find for each one another image with GPS data that is closest in time (Exif Timestamp). Then I want to copy the GPS data from the image.
I have a struct with a filename (String), date (Date) and GPS (Dictionary) and created an array for all the files (I didn't paste the function getFiles() here).
struct stFile {
var name : String
var date : Date
var gps : [String : AnyObject]?
}
Then I sort the array by the date field:
var files = getFiles(folder: "files://FolderToJpegs/")
var filesSorted = files.sorted(by: { $0.date.compare($1.date) == .orderedDescending })
All I could come up with until now is a function that finds files where the date is exactly the same (Skip files where the name is equal because that's the same file we are iterating over currently):
for file in filesSorted {
if (file.gps == nil) {
if let closesdate = filesSorted.first(where: { $0.date.compare(file.date) == ComparisonResult.orderedAscending && $0.name != file.name }) {
print("The closest date to \(file.date) is \(closesdate.date).")
}
}
}
As I'm new to swift I was wondering if there is already an easy way in version 4 to accomplish this. One way I guess would be to nest another iteration within the first one and calculate time differences.
Thanks!
Edit
Okay, so far I came up with a solution that calculates the time differences between one element and each of the others which have gps data (.gps != nil):
for (index, _) in filesSorted.enumerated()
{
if filesSorted[index].gps == nil
{
var timeDiffPrev = Double.greatestFiniteMagnitude
var closestFile:stFile?
for fileWithGPS in filesSorted
{
if(filesSorted[index].name != fileWithGPS.name && fileWithGPS.gps != nil)
{
let timeDiff = abs(filesSorted[index].date.timeIntervalSince(fileWithGPS.date))
if(timeDiff < timeDiffPrev)
{
closestFile = fileWithGPS
}
timeDiffPrev = timeDiff
}
}
if(closestFile != nil)
{
filesSorted[index].gps = closestFile?.gps
}
}
}

Answer 1

If by "closest" you mean "latest" then here is my solution for you:
First some extensions that will help us:
extension Collection where Element: Hashable {
var orderedSet: [Element] {
var set = Set<Element>()
return compactMap { set.insert($0).inserted ? $0 : nil }
}
}
Thanks to this extension we will remove duplicates from collection.
But now we need your struct to conform to Hashable protocol.
extension stFile: Hashable {
static func == (lhs: stFile, rhs: stFile) -> Bool {
return lhs.name == rhs.name
}
func hash(into hasher: inout Hasher) {
hasher.combine(name)
}
}
Thanks to above we can create function like this:
func getLatest() -> stFile? {
return files.orderedSet.filter({$0.gps != nil}).sorted(by: {$0.date.compare($1.date) == .orderedDescending}).first
}
where:
orderedSet remove duplicates (files with the same name)
filter remove files without gps data
sorted is sorting whats left from previous operations (and because orderedSet and filter was used
before, it probably has less files to sort)
EDIT:
At first I have misunderstood the question. I've hope that it is what you meant:
func copyGPS() -> [stFile] {
let uniqueFiles = files.orderedSet.sorted(by: {$0.date.compare($1.date) == .orderedDescending})
var filesWithGPS : [stFile] = []
for file in uniqueFiles {
if file.gps == nil {
let gps = uniqueFiles.filter({$0.gps != nil && $0.date > file.date}).first?.gps
filesWithGPS.append(stFile(name: file.name, date: file.date, gps: gps))
} else {
filesWithGPS.append(file)
}
}
return filesWithGPS
}