     func nextPlace(forPlace place: Place) -> Place? {
         return self.placesLock.withReadLock {
             // if the place isn't in the list, make the first item in the list the next item
-            guard let currentPlaceIndex = places.index(where: {$0 == place}) else {
-                return places.count > 0 ? places[places.startIndex] : nil
-            }
-
-            guard currentPlaceIndex + 1 < places.endIndex else { return nil }
-
-            return places[places.index(after: currentPlaceIndex)]
+            guard let currentPlaceIndex = self.placeKeyMap[place.id] else {
+                return displayedPlaces.count > 0 ? displayedPlaces[displayedPlaces.startIndex] : nil
+            }
+
+            guard currentPlaceIndex + 1 < displayedPlaces.endIndex else { return nil }
+
+            return displayedPlaces[displayedPlaces.index(after: currentPlaceIndex)]
         }
     }
 
     func previousPlace(forPlace place: Place) -> Place? {
         return self.placesLock.withReadLock {
-            guard let currentPlaceIndex = places.index(where: {$0 == place}),
-                currentPlaceIndex > places.startIndex else { return nil }
-
-            return places[places.index(before: currentPlaceIndex)]
+            guard let currentPlaceIndex = self.placeKeyMap[place.id],
+                currentPlaceIndex > displayedPlaces.startIndex else { return nil }
+
+            return displayedPlaces[displayedPlaces.index(before: currentPlaceIndex)]
         }
     }
 
     func numberOfPlaces() -> Int {
         return self.placesLock.withReadLock {
-            return places.count
+            return displayedPlaces.count
         }
     }
 
     func place(forIndex index: Int) throws -> Place {
         return try self.placesLock.withReadLock {
-            guard index < places.endIndex,
-                index >= places.startIndex else {
+            guard index < displayedPlaces.endIndex,
+                index >= displayedPlaces.startIndex else {
                     throw PlaceDataSourceError(message: "There is no place at index: \(index)")
             }
 
-            return places[index]
+            return displayedPlaces[index]
         }
     }
 
     func index(forPlace place: Place) -> Int? {
         return self.placesLock.withReadLock {
-            return places.index(of: place)
+            return placeKeyMap[place.id]
         }
     }
 
     func fetchPlace(placeKey: String, withEvent eventKey: String, callback: @escaping (Place?) -> ()) {
         self.placesLock.withReadLock {
-            if let placeIndex = places.index(where: { $0.id == placeKey }) {
-                let place = places[placeIndex]
+            if let placeIndex = placeKeyMap[placeKey] {
+                let place = displayedPlaces[placeIndex]
                 if place.events.contains(where: { $0.id == eventKey }) {
                     callback(place)
                 }

        return RemoteConfigKeys.searchRadiusInKm.value
    }()

    fileprivate lazy var places = [Place]()

    fileprivate var firstFetch = true


    }

    func allPlaces() -> [Place] {
        return displayedPlaces
    }

    func sortPlaces(byLocation location: CLLocation) {
        self.placesLock.withWriteLock {
            let sortedPlaces = PlaceUtilities.sort(places: displayedPlaces, byDistanceFromLocation: location)
            self.displayedPlaces = sortedPlaces
        }
    }
}
