     }
     
     /**
-     Updates existing `ImportableUniqueObject`s or creates them by importing from the specified array of import sources.
-     - Warning: While the array returned from `importUniqueObjects(...)` correctly maps to the order of `sourceArray`, the order of objects called with `ImportableUniqueObject` methods is arbitrary. Do not make assumptions that any particular object will be imported ahead or after another object.
+     Updates existing `ImportableUniqueObject`s or creates them by importing from the specified array of import sources. 
+     Objects are called with `ImportableUniqueObject` methods in the same order as in import sources array.
+     The array returned from `importUniqueObjects(...)` correctly maps to the order of `sourceArray`.
      
      - parameter into: an `Into` clause specifying the entity type
      - parameter sourceArray: the array of objects to import values from

              
                let entityType = into.entityClass as! T.Type
              
                var mapping = Dictionary<T.UniqueIDType, T.ImportSource>()
                let sortedIDs = try autoreleasepool {
                  
                    return try sourceArray.flatMap { (source) -> T.UniqueIDType? in

                            return nil
                        }
                        
                        importSourceByID[uniqueIDValue] = source
                        return uniqueIDValue
                    }
                }
                
                importSourceByID = try autoreleasepool { try preProcess(importSourceByID) }
              
              
                var existingObjectsByID = Dictionary<T.UniqueIDType, T>()
                self.fetchAll(From(entityType), Where(entityType.uniqueIDKeyPath, isMemberOf: sortedIDs))?
                  .forEach { existingObjectsByID[$0.uniqueIDValue] = $0 }
              
                var insertedObjectsByID = Dictionary<T.UniqueIDType, T>()
              
                for objectID in sortedIDs {
                    
                    try autoreleasepool {
                      
                        guard let source = importSourceByID[objectID] else { return }
                      
                      
                        if let object = existingObjectsByID[objectID] {
                            guard entityType.shouldUpdate(from: source, in: self) else { return }
                          
                            try object.update(from: source, in: self)
                        }
                        else if entityType.shouldInsert(from: source, in: self) {
                            let object = self.create(into)
                            object.uniqueIDValue = objectID
                            try object.didInsert(from: source, in: self)
                            
                            insertedObjectsByID[objectID] = object
                        }
                    }
                }
              
              
                return sortedIDs.flatMap { existingObjectsByID[$0] ?? insertedObjectsByID[$0] }
            }
    }
}
