Keeping an eye on data in a persistent store and

using that data in a table view or a collection view is such a common task

that we have a class whose primary function is to mediate between the two.

In our case we are adding to do items to the data store and

we want to display them in a table view.

For this, we can use an NSFetchedResultsController.

While table views can be used in several ways, fetch results controllers

are primarily intended for presenting data in a master list, exactly like we want.

UI table view expects its data source to provide cells

as an array of sections made up of rows.

We can configure a fetch results controller using a fetch request

that specifies the entity in any other optional parameters.

This fetch results controller then efficiently analyzes the results

of a fetch request and figures out how to order them in to sections and rows.

It also computes all the information for the indexes based on the results set.

This is really convenient,

it's also the most common way of using table views with core data.

So let's refactor our code to use a fetch results controller.

Now back in the ToDoListController,

We have CoreData imported up at the top which is good.

So let's add a new stored property, we don't need all these panes.

Okay, so here we're going to say lazy var

fetchedResultsController: this is of

type NSFetched, ResultsController.

And this is also generic class so it takes Item, that's our generic parameter.

Int, to set this up, we'll start by creating a fetch request.

So we'll say, let request, and in fact, we can just move this line of coding.

So copy paste the request, get it out of viewDidLoad and we'll put it in here.

Now remember, we can customize this fetch request includes sort descriptors and

additional predicates if needed.

We need this fetch request here, because the initializer for

NSFetchedResultsController takes a fetchRequest to fetch data.

In addition, it takes a managedObjectContext, and

also a thing called a section name keypath and a cache name.

So here we'll say let controller = NSFetchedResultsController, and

we'll use this initializer that takes a request.

A manageObjectContext, for which we'll need to say self,

and then for the last two we're gonna specify nil.

We'll return the controller as well.

The sectionNameKeyPath is used to precompute information about sections.

We include a key path on result objects that returns a section name.

Now we're not gonna be utilizing any of this for now so let's just pass nil in.

And then finally, it takes a cacheName.

And again here we're going to pass a nil to prevent caching.

Caches allow us to avoid the overhead of always performing fetch requests.

But again, not a concern for this course.

So earlier, we used the managed object context to execute the fetch request

ourselves.

Not any more, the fetch results controller is going to take care of that for us.

So in viewDidLoad let's get rid of this

lines of code, actually were just going to get rid of this line of code

the try managedObjectContext because we still need this do catch statement.

And now we're going to use the fetchedResultsController to do this.

So we'll say try fetchedResultsController.performFetch.

If we had run it at this point, nothing's going to happen, and that's because

the table view data source methods are now looking at the wrong data set for values.

We won't be assigning anything back to the item's stored property when we

use the fetchedResultsController.

So let's get rid of that and any associate lines so, var items out of here.

Okay, so now we're gonna have errors in our data source methods, that's okay.

So we'll start with a number of sections, the fetch results controller has

a sections property that contains information about the sections for

the receivers fetch results.

So here for number of sections we'll say return

fetchedResultsController.sections.count.

And you'll see that this is an optional property because there may not be a need

for multiple sections.

So if we don't have any section information in this controller, meaning

our fetch request failed potentially, then we'll use the nil coalescing operator,

and we'll say if this is new, then use 0.

Okay, so if there's a valid value for this, the nil coalescing operator's gonna

unwrap it and return it, otherwise we'll return 0.

Okay next is the number of rows in section.

The fetch results controller can contain many sections, much like a table view can.

So first, we need to get the relevant section to work with.

Now, notice that the data source method contains a parameter for section.

And as the table view is setting up its sections,

it's going to pass that argument through to this function.

In this case, in our case, it would just be one.

But we can use this section as an argument in the fetch results controller as well.

So here we'll say guard let section = fetchedResultsController.sections.

Now, this is an array of sections, so we'll use the subscript notation and

pass the argument through from the data source method

to get the current section that we want.

So when our tableView sets itself up, this is going to be 0.

Because we have one section, so

from this array of sections we're going to get the zeroth section.

Now again, this is an optional property so we need to put that question mark there.

And if that returns nil then we don't have any sections, so we don't have any rows so

it'll return 0.

Okay, once we have a section though, see if this guard statement works,

we can simply say return section, which is of type NSFetchedResultSectionInfo and

it has a property numberOfObjects.

So, hopefully that makes sense.

We grab a section out of the fetchedResultsController.

That section contains information about what goes into each row and

we're just going to call the number of objects property on it.

For the final bit, we need to customize each cell.

Remember that a fetchedResultsController can compute

all the information about rows and sections using an index path.

So, let's create a private helper that takes a cell object and

an index path and returns a configured cell.

So down here we'll say private func configureCell and

this is going to be of type UITableViewCell, atIndex path,

or we'll just say at indexPath.

I'm saying just at because the argument type is specific enough that it's obvious

what at means.

And then this method is going to return fully configured UITableViewCell instance.

Now inside this method the first thing we need to do configure a cell is

an item object.

So we say let item = fetchResultsController.

And it has a handy method object(at: indexPath), so

again pass the indexPath through.

When we created the fetchedResultsController, we set it up.

This is a generic type, we gave it a generic parameter of item.

So calling this method returns an instance of item, so

we don't need to do any casting.

Now, we can assign the item's text to the cell's text label and return it.

So we'll say cell.textLabel.text = item.text and return cell.

Back inside cell for an indexPath,

once you grab the cell all we'll do is say, we'll get rid of all of this.

We'll say return, configure cell we'll pass the cell through and the indexPath.

Run the app now, and you should see the new data displayed.

Also notice that it is sorted, perfect, but if you tried to add a new task,

you'll see that we still run into the issue where adding a new item

is not going to trigger a change.

Wait, what, I thought the fetchedResultsController handled that?

It does but we still need to do a few more things.

Let's tackle that in the next video.