All right, so I have created a shell of an application,

which are starter files basically.

it contains a table view controller.

Where all the items are going to go off our shopping list.

And when you click on Add, it goes over to the Detail View Controller.

Which contains the item title the quantity and a category.

However, we're not going to worry about the category for now.

We're just going to worry about the title of the item.

Like what are we buying in our shopping list.

It's a grocery shopping list.

So, we're buying fruits, vegetables, housewares, cleaning products.

Whatever in the quantity.

And when you click on done, it goes back over to the table view controller.

All right, so first things first.

We need to add the Swift framework to our projects and

for that we need to head on over to realm.io.

And once you get to realm.io, you're going to click on docs.

And then, you're going to select from the realm mobile database whether it's Java,

Objective C, React Native, Swift or Xamarin.

In our case it is Swift.

So we click on Swift.

Click on Getting Started and then, you're going to click on download.

Once it has downloaded,

within that folder you'll see several different of sub folders.

So there's iOS, OS 10, TV OS, Watch OS.

There is the plug in and you have examples.

So if you click on iOS, it will give you the various versions of Swift.

We're working with Swift 3.0, so that's what I have selected here.

And then, we'll head on over back to X code.

Click on the project's.

Click on general.

You're going to scroll all the way down and

under embedded binary, that's where we're going to drag and drop these two files.

I will just drag and drop here.

Make sure that you select copy items if needed and then, hit finish.

So just to tidy things up, I am going to drag it under this grouping called

frameworks that I've created, all right.

So the next thing that we need to do is, create model objects.

So in our shopping list application, the model object that we need

is a shopping item that you're going to add to your list.

So, we'll create a swift file and we'll call this item.

So since this is a realm model object,

we first need to import RealmSwift.

The next thing we need to do is, say it's a class item, which sub-classes object.

All Realm model objects need to subclass object.

So that the Realm framework knows that these are the model objects basically.

And that these are managed objects that they are managed by the ram database.

And it can store data and persist data into the ram database.

So the next thing you need to do is, define our properties.

So in our case, instead of just saying var, we have to say dynamic var.

And in this case, we'll say title and we'll initialize it to an empty string.

We'll say dynamic var qty = 0.

So, why did we use the keyword dynamic?

Well, we use the keyword dynamic, because it means the getters and

setters of this class are synthesized by its superclass.

In this case by object,

which means these properties are going to be managed by the superclass.

All right, so that's all it takes.

That's how we define a model object in Realm and now,

we need to use this model object.

So, I'm going to go over to our master view controller and

this is where we need to define our data source.

So, what is our data source?

Well, our data source is an array of items.

Now what we want is, something like a fetch results controller, right.

In a code data, you have a fetch results controller.

That mediates between the persistent store, which is your database.

And your Table View Controller, where it manages the object graph.

What data is going inside it.

What data is coming out of it and then, it notifies the UI that, hey,

something happened.

And so, that you can update your user interface or

automatically updates your table view controller.

In the case of REM, you have a results class, right.

So, you can query it and you can get back results and

you know you can chain queries with the results.

So we'll come back to results, but we need an array of items.

We have created an item model object and we need an array of them.

So here, I'll declare var items.

So, this is a simple array of items and I'm going to put a question mark,

because it's an optional.

We don't have an initializer.

And over here in number of rows, I'll just say,

items.count and if that is nil, then we'll say zero.

And then, we need the cell for row at IndexPath.

So, declare a cell.

We'll say cellis equal to table view.dqreusable cell

with identifier index path.

So, the identifier is declared in our main.story board.

If we go over here, we can click on the cell

And look at the properties inspector and

see that our identifier is cell with a capital C.

All right, so cell and the index path, well index path is being passed to us.

So, that's index path.

We'll say, let item equal items indexpath.row.

Then we'll say, cell.text.label.text =

item.title and finally, we return to cell.

And I believe the compiler is complaining,

because it says it's immutable and we need to declare a mutable cell.

So we'll say var, because we are modifying it and that's an optional.

So, we can wrap this in a if let statement.

All right, so now it's saying we can change it back to a let.

All right, so this will display a list of items.

That's great, but we need to have a mechanism

off inserting items into the realm database.

And this is where the Detail View Controller comes into play.

So we'll go into the Detail View Controller.And when the done

button is tapped, we're going to see how to add data into our ram database.

So what we need to do is get the title that the entered in the text field.

And we need to get the quantity that they entered in the quantity text field.

So we'll add a couple of guard let statements.

So we'll say guard let title=title

text field.text,let

quantity=quantity text field.text Alt.

We're going to put this out in a separate function.

We'll say dismiss.

So instead of calling this in two different places,

we have factored it out into a separate method.

So just say dismiss true,

in here as well, dismiss true.

I'll delete that from this method, right.

So now we have two constants, our title and our quantity.

Var item is equal to item.

So in this case, we're just assuming that we're creating a new item.

We'll later on see how we can update an item.

So item.title is equal to the title

and item.quantity is equal to quantity.

So now that we've created a new item, we need to store this item into rum database.

So in order for us to store this item into the rum database,

we need a reference to rum.

Like a mechanism to communicate with rum.

And you can do that with one line of code.

With core data you have to have a managed objects within the manage object contacts.

Which has a persistent controller, all of those crazy layers.

In this case, no crazy layers.

Just one object, which is realm.

So we'll let Realm equal to try Realm.

That's it.

And then we'll say realm.write and we'll say realm.add.

Because we're adding a new object to the ream database.

Right, so we have a few compiler errors.

Let's see what the first one is.

It says use of unresolved identifier realm.

That's because we have an imported realm swifts because we're using realm

under swift.

So we have to import realm swift and so that compiler warning has been silenced.

Now let's see what is this one.

It says cannot assign value of type String to type int.

Right.

So when we declared this round model object, it is an integer.

What we get back from the text field is an string, because text is of type String.

So what we can do is, inside this guard let, we can now type cast this.

We can convert this from a string to an integer and it is complaining.

It's saying optional.

All right, so we're going to implicitly unwrap that.

Finally, once again, it's complaining.

It's is when we do a write transaction, it throws an error.

And we're not catching that error.

So instead off actually just forcing a try over here, I would rather do a do block.

Now let's do a try.

So in a real world application, we will catch this.

And we will gracefully display the error message to the user.

For now, I'm simply going to print it out to the console.

But we should gracefully display an error message to the user saying like, hey.

We were unable to save this item to the database.

All right.

We still have some things.

It's a item was never mutated.

Change this to constant and filing this one.

It's a guard body me not fall through.

So the problem is that we call dismiss.

We will also need to call a return.

We're putting it all on the same line.

We're going to put a semi colon.

And say return and this will dismiss the view controller.

And to get out off this method the done

All right, so let's recap what we did here.

We got an instance of Realm.

We created a new model object and saved, assigned values to the properties.

And then we simply created a write transaction,

where we instructed round to add a new object to the realm database.

And since this right transaction can throw an error,

we wrap that in a do catch block.

Right, so let's run our application once again and see if that works.

So, I am going to add apples to my shopping list, because I love apples.

Now, let's say six apples and we hit done.

And nothing shows up in our Table View Controller.

So hit stop.

And I will hit run again to see if actually save something to the database.

So nothing happened here.

Then actually write ending thing to our database.

It's either that or I messed up in the Table View Controller.

Let's see.

Right, so I have an array of items.

But I am never instructing the round database to

extract that array of items from the database.

See, we're just declaring an array of items.

But nowhere am I saying I'm split,

nor am I saying like hey real, give me this array of items from your database.

So let's do that.

So, do import realm swifts.

Some going to get an instance off realm over here.

We'll say realm is equal to try realm.

And this will be a property for our view controller.

And we'll create a getter method.

And inside this getter method, we will use the realm property,

we'll say realm.objects.

So in our case, we want all the items to be displayed in our view controller.

So you can use this convenient method that says objects of type whatever.

And if you have a primary key, then you can specify the primary key.

So in our case, all we have is the object of Type item.

So I'll say objects, type item.self or of saying like all right off this type.

To give me back all of the object of this type.

Now this method, if I command click on it, it returns a realm swift result.

That's what it's returning.

It's returning a type Results.

So let's Cmd+click on Results and see what that is.

So results is a class.

And if I scroll up here, it says,

Results is an auto-updating container type in Realm returned from object queries.

Results can be queried with the same predicates as list.

And you can chain queries to further filter queries.

So it can give us back results and we can display these results.

You can index into them.

You can subscript them, you can get first last.

So results kind of behaves like an array.

And if you wanted an array, you can see value for a key.

Where you're actually specifying the key if you're returning back a dictionary.

So has all kinds of methods if you're going to round up IO.

You can get further help.

You can see a collection and you can look at results and look at the API.

You can read through what kind of methods results provides.

All right so instead of this being an array of items,

this is really going to be of type results.

And since this is a generic type,

we're going to specify that it's a results of item.

What happens to the rest of our ViewController.

Now this is no longer an optional, so

of course we're going to get some errors in our code.

So the compiler is saying delete the question mark because it's

no longer an optional.

So if we delete that, then we need to delete the nil coalescing operator.

And here, we're going to delete this as well.

All right, so now we can run our app.

But it won't let us run it because we have an if let statement here, all right?

We can get rid of that as well.

Okay we are running our application.

So hopefully, it displays that one item that we added.

Great.

Now if I add another item.

Let's say I added bananas and I want 12 bananas.

Hit done, and wow, there is our item bananas.

And let's say I'm going to add Windex, that's a window cleaner.

At least here in the United States.

I need one of those, then I hit Done and there you go.

There is our Windex.

So as you can see, in a few short minutes, we were able to create a model object.

Access the round database.

And persist data to the ROM database.

All the while displaying that list of items in the Table View Controller.

So coming up in the next video, will see how we can update each item.

And we can delete those items and finally we will see how we can

categorize the items using the category relationships.