For the gate logic, we're going to create a separate type entirely

as a nested object in control tower just like runway and terminal.

Here's what our code needs to do.

We have a set of gates for

each terminal that we need to query every time a plane requests a space.

The information about terminals is encoded in the terminal type.

So we could associate the terminal's gates with each enum member.

Now one way we can do this is to use computed properties, so for

example, we could have a computed property that returns the list of gates for

terminal A, B, C, and so on.

But unfortunately, that has its limits.

A computed property has no storage in memory and either returns a static value

every time or one that is computed from stored properties.

We cannot use a computed property because we can't return the same gates every time.

Let's say Terminal A had three gates, 1 through 3.

An airline requests to park, and so we say go ahead and park at A1.

If we use a computed property for the gates,

we're going to return the gates 1 through 3 every time.

Enums can't contain stored properties either.

So, to get around this,

we're going to encode the gate information in a different type altogether.

There are other ways to do this, but because I want to show you certain

things about protocols and enums, we'll go down this round.

The nice thing though is the way we're about to implement gate logic,

we're going to learn a few more things about Swift in the process.

So, right after the terminal enum, let's add a new type,

and we'll name this GateManager.

And this is going to be a class.

We're going to add four stored properties to this class to keep track of the status

of various gates in the terminal.

I'm going to copy paste this in, and

as always, you can grab the code from the link in the teacher's notes as well.

For these properties, we're using good old dictionaries and

arrays to keep track of what gates are available.

The first property, for example, gates for

terminal A keeps track of the gates for terminal A obviously.

The property contains a dictionary on the outside with two keys, occupied and empty.

Using each key gets you an array of integers

pertaining to the different gates available.

Now there are ways we can improve this rather than using nested collection types,

but I'm going to set that as an exercise for you.

Get that brain of yours thinking.

So the logic here is pretty simple.

When Delta Airlines requests landing,

we know it's Terminal A based on the logic we wrote earlier.

So we queried the gatesForTerminalA property.

Using the key empty, that's this one here, we check if there are any empty gates.

If yes, we return the value.

Otherwise, we return nil.

When an empty gate is assigned to a flight,

we need to update the stored property.

So let's say we assign gate 9 for the flight to land at or park at.

Well, now 9 isn't empty anymore, so

we need to move 9 over into the occupied list.

So to start, in this class, let's write two methods to get this work done.

So first, we'll write a method to update the gate.

So we'll say func update.

This method is going to take a property that lists the gates.

So now this type is this thing here, string,

a dictionary with strings as keys and then array of integers as a value.

And then it will also take a gate as an integer.

Given a particular date, we want to switch it from the empty to the occupied array.

So let's say we call this method update.

And for gates, we pass in gates for terminal A, and

the gate number as number 9.

We want to remove the gate 9.

We want to remove the value 9 from the empty array and

add it to the occupied array.

So the first thing we'll do in our method is get the list of occupied gates for

a particular terminal.

So we'll say if var occupiedGates = gates,

and we'll use the key occupied.

The gate's dictionary here represents the collection of gates for a terminal.

And using the occupied key, we can get all the occupied gates.

You'll notice that we're doing something we've never done before, and

that's specifying if var instead of if let.

if var creates a variable that can be modified,

whereas let creates a constant value.

The reason we want a variable is now that we have an array,

we're going to append the gate value.

So this occupied gates is now this list or this array of gates,

and to that, we're going to append the new gate.

That's this thing right here, saying append(gate).

Now we've taken the gate and assigned it to the occupied list.

You'll notice we didn't modify the array contained within the dictionary directly.

We created a copy by assigning it to a local constant or

local variable when we modify that variable.

So now, now that we've modified it, we're going to use updateValue forKey

on the gate's dictionary and reassign this array as a value.

So we'll say gates.updateValue forKey.

And for the value, we are going to pass in the occupiedGates, and for the key,

we'll say occupied.

This does not work however, and the reason for that is the gate's value.

This right here is a function argument as you can see here.

And function arguments are immutable within the body of a function.

We can work around this by specifying var in front of the parameter,

but this is a temporary solution.

If you click on this, it says that var parameters are deprecated and

will be removed in Swift three.

So let's delete that.

To future proof our code, what we can do is pass by reference.

And we do this using the inout keyword in front of the parameter.

Now, previously, before we added this, if we call this method, update, and

passed in gatesForTerminalA, what we actually pass in is a copy of this value.

Remember that Swift dictionaries are value types.

By adding the inout keyword in front of our parameter,

now when we call the method, we are actually passing by reference.

So again, if we call this method and pass in gatesForTerminalA as the argument,

by modifying gates inside the body of the method, we're modifying gates for

Terminal A directly.

Okay, so now this works.

Now on the flip side, now that we've added the gate to the occupied list,

we also need to remove it from the empty list.

Now this code is pretty straightforward.

First we get the list of empty gates using the empty key.

Then we get the index of the value we're trying to remove.

So we'll chain this and say,

let index = emptyGates.indexOf and we'll pass in the gate.

Now once we have these two values, we can easily remove the gate by saying,

emptyGates.removeAtIndex, and pass in the index that we just obtained.

Now our emptyGates actually reflects the updated status of the gates.

So we can assign this back to the gates property by saying

updateValue forKey and using the relevant key value pair.

So far so good.

While this method doesn't actually determine if a gate is empty,

it ensures we're not assigning the same gate to two flights.

In the next video, let's implement the actual gate sorting logic and

finish off the gate manager.