The next step after converting our plist into a generic dictionary object

is to make an actual inventory out of it.

For that we're going to create another tiny class

which we'll place right below PListConverter.

We'll name this InventoryUnarchiver, like the Plist

converter we'll give this class is single class method.

We'll say static, func.

We're going to name this vending inventory from dictionary.

And it's going to have a single parameter of type String: to AnyObject,

which matches the return type of the plist converter method.

Now if you go back up and look at the protocol right over here,

you'll see that the type of an inventory is VendingSelection: to VendingItem.

So we'll set the return type of this method, down here,

vending inventory to output such a dictionary.

So we'll return vending selection to vending.

Admittedly we could make this more flexible right now the type of

an inventory as defined by the protocol is always vending selection to vending item.

Now a vending item is itself a protocol because remember that protocols are types

themselves.

This means that we aren't restricted to a single type we can pass in

as a value in an inventory object.

We can put in here anything that conforms to vending item.

The type of the keys however is vending selection which is a concrete type.

It's that enum that we've defined that sets the different items we can select

from our machine.

If we wanted to create a vending machine for books we've got an issue here.

We can't specify anything other than vending selection and so

far that type only encapsulates food and drink.

We could add our books to this enum but

that doesn't make sense it doesn't fit in the type.

For now though we'll ignore this constraint.

We've already got a lot of abstraction going on and

we'll touch on this in the future.

Hopefully though this still highlights the flexibility

of protocols to define structure in our code base without the need for

subclassing or any concrete types pretty early on.

Again this return type, is specified over here,

the VendingItem part of the return type is a protocol.

Which gives us a sort of freedom to return any type that conforms to this protocol,

and we don't have to subclass.

So inside this method we'll start out by creating an empty

dictionary inventory to match the final one that we want to output.

So var inventory, this is of type vendingSelection to vendingItem,

and then to this variable, we'll just assign an empty dictionary start.

Before we forget let's go ahead and

return the inventory because that's what we eventually want to do with this method.

Now in between these lines of code let's get it set up.

Our source dictionary that we're passing into the method as an argument

contains some values.

So let's iterate over the keys and values so that we can inspect and

work with each pair.

So we'll say for (key,

value) in dictionary.

And now we can iterate over the entire thing and look at each pair.

The keys in this dictionary are strings.

Eventually we want to get that to vending selection but for now that's okay.

The values on the other hand are any object, and

we can't really work with any object.

We need to first cast it to a more specific type.

If you go over to the vendinginventory.plist file and

inspect the contents of a particular entry you'll see that it's another

nested dictionary with a string for a key and double values for a number.

So let's cast the value from each iteration to a more appropriate type.

In this case, again, the value is another nested dictionary.

Now I made a mistake earlier these aren't both double values

the quantity value is an integer and the price value is a double value.

Now, since these are different types.

We have a double here, and integer here.

When casting this nested dictionary to a more concrete type,

we need to either define the type of the dictionary that contains them,

as having values that are of a higher type, like any object or any or

try to cast a more specific concrete types.

Any object though doesn't work here.

For example, this is easier to explain in code.

So if I say if let itemDictionary =, so

we want to cast a value which is of type any object to something more concrete so

we'll say value as.

And then I could do string to any object here.

But this doesn't work because remember any object represents a class type and

the different values that we're going to find in this dictionary,

item dictionary are either an int or.

So we're going to cast to any.

So now we have that nested dictionary that we've pulled out using a particular key.

We've cast that to a string to any so if we want to get price we use the price key

and if we want to get quantity we use the quantity key.

Now if you remember your dictionary basics you know that retrieving a value

from a dictionary using the key as we're about to do

always returns an optional because that key may not exist.

So rather than performing that logic inside this if let statement.

Let's add two more checks to this single if let statement to get the price and

quantity as well check for new values and unwrap them.

So first is the price so we'll say let price = and

we're going to get price from the item dictionary using the price key.

And right now the values that we get out of item dictionary are of type any so

we need to cast that to a more specific type.

So we'll say as double.

If that works everything is bound to price so

we have one more check we'll say let quantity =,

itemDictionary, we'll use the quantity key.

And this time we'll cast this to an integer.

If this succeeds, we have the values for price and quantity.

Using these values, we can now create an instance of item,

which is a type that conforms to VendingItem.

So we'll say, let item = Item and

we use initializer to pass through the price and the quantity.

Now that we have an item we're one step closer to adding a key value pair to our

dictionary.

The key is here again our P list strings right,

they're strings that we got out of our P list dictionary.

But our inventory, so

we want to add this item along with a key back into the inventory.

The problem is that we need vending selection rather than a string.

So we need to convert from one type to another.

Let's handle that in the next video.