ios - tutorial - Uso de 2 FRC con una TableView y configuración de FRCDelegate

swift 4 core data tutorial

Question

Encontré este enlace de la pregunta posterior, y he hecho mi mejor esfuerzo para convertirlo de Obj-C a Swift. Cuando agregué una nueva Entidad e intenté guardarla en CoreData, la aplicación se bloquea y resalta esta línea:

modifiedIndexPath = NSIndexPath(row: (indexPath?.row)!, section: 0)

El error en verde detrás de esto es el siguiente: Thread 1; EXC_BREAKPOINT (code=1, subcode=0x100008b118) Thread 1; EXC_BREAKPOINT (code=1, subcode=0x100008b118) . No tengo idea de lo que esto significa, y el panel de salida solo muestra (llbd) en verde también.

EDITAR - Me di cuenta de que la aplicación está fallando porque indexPath? .row está devolviendo nulo. Simplemente no sé por qué está volviendo nulo.

Mi VC tiene 2 secciones configuradas así:

 func numberOfSections(in tableView: UITableView) -> Int {
return 2
}

Y el título para el encabezado se establece así:

// set the titles of the tables
func tableView( _ tableView : UITableView, titleForHeaderInSection section: Int)->String? {
switch(section) {
case 0:
if(positiveFetchedResultsController.fetchedObjects!.count == 0){
return nil
}
else{
return "Owes you:"
}
case 1:
if(negativeFetchedResultsController.fetchedObjects!.count == 0){
return nil
}
else{
return "You owe:"
}
default :return nil
}
}

Así es como estoy creando mis dos RFCs

override func viewWillAppear(_ animated: Bool) {
// load the data
let fetchRequest: NSFetchRequest<Person> = Person.fetchRequest()
fetchRequest.predicate = NSPredicate(format:"[email protected] >= 0")
let sort = NSSortDescriptor(key: #keyPath(Person.name), ascending: true)
fetchRequest.sortDescriptors = [sort]
positiveFetchedResultsController = NSFetchedResultsController(fetchRequest: fetchRequest, managedObjectContext: coreDataStack.managedContext, sectionNameKeyPath: nil, cacheName: nil)
do{
try positiveFetchedResultsController.performFetch()
}catch let error as NSError{
print("Fetching error: /(error), /(error.userInfo)")
}
let negativFetchRequest: NSFetchRequest<Person> = Person.fetchRequest()
negativFetchRequest.predicate = NSPredicate(format:"[email protected] < 0")
let negativeSort = NSSortDescriptor(key: #keyPath(Person.name), ascending: true)
negativFetchRequest.sortDescriptors = [negativeSort]
negativeFetchedResultsController = NSFetchedResultsController(fetchRequest: negativFetchRequest, managedObjectContext: coreDataStack.managedContext, sectionNameKeyPath: nil, cacheName: nil)
do{
try negativeFetchedResultsController.performFetch()
}catch let error as NSError{
print("Fetching error: /(error), /(error.userInfo)")
}
positiveFetchedResultsController.delegate = self
negativeFetchedResultsController.delegate = self
print("/(positiveFetchedResultsController.fetchedObjects!.count) positive fetch count")
//print("/(positiveFetchedResultsController.fetchedObjects![0].statement!.count) positive statements count")
print("/(negativeFetchedResultsController.fetchedObjects!.count) negative fetch count")
//print("/(negativeFetchedResultsController.fetchedObjects![0].statement!.count) negative statements count")
}

Aquí está el código de delegado de FRC que convertí de la publicación anterior:

extension ViewController: NSFetchedResultsControllerDelegate {
func controllerWillChangeContent(_ controller: NSFetchedResultsController<NSFetchRequestResult>) {
tableView.beginUpdates()
}
func controller(_ controller: NSFetchedResultsController<NSFetchRequestResult>, didChange anObject: Any, at indexPath: IndexPath?, for type: NSFetchedResultsChangeType, newIndexPath: IndexPath?) {
var modifiedIndexPath = IndexPath()
var modifiedNewIndexPath = IndexPath()
if(controller == positiveFetchedResultsController){
modifiedIndexPath = IndexPath(row: (indexPath?.row)!, section: 0)
modifiedNewIndexPath = IndexPath(row: (newIndexPath?.row)!, section: 0)
}
if(controller == negativeFetchedResultsController){
modifiedIndexPath = IndexPath(row: (indexPath?.row)!, section: 1)
modifiedNewIndexPath = IndexPath(row: (newIndexPath?.row)!, section: 1)
}
switch type {
case .insert:
//tableView.insertRows(at: [newIndexPath!], with: .automatic)
tableView.insertRows(at: [modifiedNewIndexPath as IndexPath], with: .automatic)
case .delete:
//tableView.deleteRows(at: [indexPath!], with: .automatic)
tableView.deleteRows(at: [modifiedIndexPath as IndexPath], with: .automatic)
case .update:
tableView.reloadRows(at: [modifiedIndexPath as IndexPath], with: .automatic)
case .move:
//tableView.deleteRows(at: [indexPath!], with: .automatic)
//tableView.insertRows(at: [newIndexPath!], with: .automatic)
tableView.deleteRows(at: [modifiedIndexPath as IndexPath], with: .automatic)
tableView.insertRows(at: [modifiedNewIndexPath as IndexPath], with: .automatic)
}
}
func controllerDidChangeContent(_ controller: NSFetchedResultsController<NSFetchRequestResult>) {
tableView.endUpdates()
}

}

EDITAR Parece que IndexPath.row es return nil para indexPath y newIndexPath. Traté de evitar que esto sucediera con este código, pero no sé si voy en la dirección correcta con este proceso de pensamiento:

 print("/(indexPath?.row) is the index row number")
print("/(newIndexPath?.row) is the NEW index row number")
if(controller == self.positiveFetchedResultsController){
if(indexPath?.row == nil)
{
modifiedNewIndexPath = IndexPath(row: 0, section: 0)
modifiedNewIndexPath = IndexPath(row: 0, section: 0)
}
else{
modifiedIndexPath = IndexPath(row: indexPath!.row, section: 0)
modifiedNewIndexPath = IndexPath(row: (newIndexPath?.row)!, section: 0)
}
}
if(controller == negativeFetchedResultsController){
if(indexPath?.row == nil)
{
modifiedIndexPath = IndexPath(row: 0, section: 1)
modifiedNewIndexPath = IndexPath(row: 0, section: 1)
}
else{
modifiedIndexPath = IndexPath(row: indexPath!.row, section: 1)
modifiedNewIndexPath = IndexPath(row: (newIndexPath?.row)!, section: 1)
}
}

Y aquí es cómo estoy tratando de guardar mis datos:

/* STEP 2 - Check to see if that persons names was already used */
let personFetchRequest: NSFetchRequest<Person> = Person.fetchRequest()
personFetchRequest.predicate = NSPredicate(format: "name == %@", name.text!)
do{
let results = try coreDataStack.managedContext.fetch(personFetchRequest)
print("/(results.count) this is the results count for the predicate")
guard results.count == 0 else{
// print("The Same Name is Used")
warningText = "You already used that name."
warningMessage()
return
}
/* STEP 3 - Use the name that was typed in */
print("You can use that name")
//let personEntity = NSEntityDescription.entity(forEntityName: "Person", in: coreDataStack.managedContext)
let person = Person(entity: Person.entity(), insertInto: coreDataStack.managedContext)
person.name = name.text
/* STEP 4 - Save the data */
coreDataStack.saveContext()
self.dismiss(animated: true, completion: {});
}catch{
print("Error")
}

Parece que se bloquea justo después de esta declaración de impresión

print("You can use that name")

No puedo guardar en CoreData, y no estoy seguro de por qué.

EDITAR Esto parece haber solucionado mi problema, todavía estoy probando, pero parece estar funcionando.

func controller(_ controller: NSFetchedResultsController<NSFetchRequestResult>, didChange anObject: Any, at indexPath: IndexPath?, for type: NSFetchedResultsChangeType, newIndexPath: IndexPath?) {
var modifiedIndexPath = IndexPath()
var modifiedNewIndexPath = IndexPath()
print("/(indexPath?.row) is the index row number")
print("/(newIndexPath?.row) is the NEW index row number")
if(controller == self.positiveFetchedResultsController){
if(indexPath?.row == nil)
{
modifiedNewIndexPath = IndexPath(row: 0, section: 0)
modifiedNewIndexPath = IndexPath(row: (newIndexPath?.row)!, section: 0)
}
else if(newIndexPath?.row == nil){
modifiedIndexPath = IndexPath(row: indexPath!.row, section: 0)
modifiedNewIndexPath = IndexPath(row: 0, section: 0)
}
else{
modifiedIndexPath = IndexPath(row: indexPath!.row, section: 0)
modifiedNewIndexPath = IndexPath(row: (newIndexPath?.row)!, section: 0)
}
}
if(controller == negativeFetchedResultsController){
if(indexPath?.row == nil)
{
modifiedIndexPath = IndexPath(row: 0, section: 1)
modifiedNewIndexPath = IndexPath(row: (newIndexPath?.row)!, section: 1)
}
else if(newIndexPath?.row == nil)
{
modifiedIndexPath = IndexPath(row: indexPath!.row, section: 1)
modifiedNewIndexPath = IndexPath(row: 0, section: 1)
}
else{
modifiedIndexPath = IndexPath(row: indexPath!.row, section: 1)
modifiedNewIndexPath = IndexPath(row: (newIndexPath?.row)!, section: 1)
}
}
print("/(indexPath?.row) is the index row number")
print("/(newIndexPath?.row) is the NEW index row number")
switch type {
case .insert:
print("/(newIndexPath?.row) is the NEW index row number")
// tableView.insertRows(at: [newIndexPath!], with: .automatic)
tableView.insertRows(at: [modifiedNewIndexPath as IndexPath], with: .automatic)
case .delete:
//tableView.deleteRows(at: [indexPath!], with: .automatic)
tableView.deleteRows(at: [modifiedIndexPath as IndexPath], with: .automatic)
case .update:
tableView.reloadRows(at: [modifiedIndexPath as IndexPath], with: .automatic)
case .move:
//tableView.deleteRows(at: [indexPath!], with: .automatic)
//tableView.insertRows(at: [newIndexPath!], with: .automatic)
tableView.deleteRows(at: [modifiedIndexPath as IndexPath], with: .automatic)
tableView.insertRows(at: [modifiedNewIndexPath as IndexPath], with: .automatic)
}
}

Parece que se asignan sentencias if / else para este tipo de cosas. Esperando que alguien tenga una versión más limpia de esto.