The second part of our Core Data stack is the managed object model.

It's important to remember that the managed object model

is not the model objects themselves but the entire object graph.

Think of it this way, each model, lets a for example,

an employee class is a managed object.

Our object graph could contain three manage objects, employee, manager, and

department.

The managed object model, which we're about to create, is a schema or

outline of all the managed objects and their relationships to one another.

Remember I said that Core Data is good at maintaining these relationships.

Well, that's what the managed object model does.

While the managed object model is created in code,

we'll actually use a graphical user interface,

a GUI editor to create each managed object, but more on that in a bit.

The managed object model is represented by the class NS managed object model.

And to use this class in our code, we need to import the Core Data framework.

So up at the top here in this file we'll say, import CoreData.

We'll create the managed object model as a lazy store property with a closure

just like we've been doing.

So we'll say, lazy var managedObjectModel

of type NSManagedObjectModel.

Just as in FYI, if you're doing this pattern where you are specifying the type

and then assigning a closure that you call immediately, if you don't assign this

type it's not gonna work first of all, because it can't infer it.

And secondly, if you don't go ahead and return the object of that type

immediately, you might run into these cases where the compiler doesn't know how

to auto complete or it returns an error on some of these things.

And that's again because it can't infer the type.

So just keep in mind that you're not doing anything wrong,

it's just the compiler trying to figure things out.

The body of the closure is pretty simple.

Since we'll be creating the managedObjectModel using a GUI editor,

we can initialize the managedObjectModel in code from a file.

But first we need a URL for the file that we're going to initialize it with.

We haven't created this file yet, but let's go ahead and obtain a URL for it.

We can do that because we know the name, since when we created that file,

we'll give it the same name.

We're going to use the bundle class to find the URL for

a resource in the main bundle.

So let modelUrl = Bundle.main.url for resource,

and this is going to take a resource name and an extension.

So here we'll say TodoList, uppercase L.

And the extension is momd, so M-O-M-D.

And we're going to force unwrap this, because it creates an optional.

Now the resource name here is TodoList and

the extension momd we'll talk about that more in a second.

Now that we have a URL that we've unwrapped, let's create and

return a managed object model.

So we'll simply say return NSmanageObjectModel.

It has an initializer that takes contents of a URL and we'll pass in the model URL.

Now again this initializer is a failable one,

if we can option click it we don't, we get an error.

So what we're gonna do is force unwrap this as well.

Now, this is unsafe if you're thinking that you're right.

But in this case,

we actually do want the program to crush if we can't load our managed object model.

Because then we can't use any of these.

And that is the managed object models done.

Let's make one quick change here.

When we use this Core Data stack in the rest of our app,

we don't want anyone modifying these properties that application document

directly in the managed object model and so on.

So we are going to make them private properties.

Now we've learned how to make properties and methods private before.

And we used a private keyword to do that.

But again there's more nuance to it and we've touched on this before.

But if I want these properties to be readable publicly but not setable.

So essentially what we want to do is make the setter private, but the getter public.

To do that, we'll say private[set].

And we've touched on this before, but it's a nice reminder.

So we'll copy that and paste it down here as well.

So now we could read these properties if we wanted to,

from this core data stack class, but we can't set it.

So this ensures that we can only modify the properties from inside the class.

The NSManagedObjectModel instance

describes the data that is going to be accessed by the Core Data stack.

During the creation of the stack,

the NSManagedObjectModel often referred to as the MOM, for managed object model,

is loaded into memory as the first step in the creation of the stack.

Now once this object is initialized, the coordinator object is constructed.

So let's go to that next.