We've implemented the runway, terminal, and gate lodging.

So let's tie it all together in land method of the control tower,

which is down here.

Earlier, when we implemented the logic for the terminal enum, we simply returned

enum members with the associated values set to nil as a temporary workaround.

So let me actually scroll back up to Terminal for a second.

And over here, you can see we're simply returning A and nil values,

no actual gate numbers.

To fix this, now we can go back in and enter a couple lines of code for

each case in the switch statement.

So if it's a domestic airline and more specifically,

it's a Delta flight, let's get a gate for Terminal A.

So we could say let gate = GateManager.sharedInstance.gateFor and

we'll say Terminal A.

Now this returns a integer value as the gate, so we can use that in here.

When we specify the terminal for the GateManager's instance method,

we just pass in nil for the associated value to satisfy the compiler.

We don't really have a gate number at this point.

With the gate value we get back,

we assign this as an associated value to the relevant enum member and return it.

So let's repeat this process for every airline.

So we'll say let gate, I can just copy this.

And, let me go change everything so

this is B, this is C, this is International,

and the last one is Private.

And then finally, we need to use that gate as an associated value.

Now you could modify the gateFor terminal that's this method over here

you could modify this method to return a terminal value instead of just an integer.

That should allow you to clean up the terminal logic as well and

eliminate a lot of repeated code.

Now, I haven't done that specifically,

because I want you to try it out as a refactoring exercise.

No guidance, just try and improve this code on your own.

Okay, with that done, let's head back down to the land method.

We already have the runway over here, so all we need is the terminal.

So we can say let terminal=Terminal.terminal and

we'll pass in the airline, super simple.

The airline protocol encodes the type information and we can cast the type to

a more specific type and figure out things, all of this we've already done.

So let's add a terminal store property to the landing instruction struct now that we

have it, so that we can return it.

So we'll say let terminal, and just like the type for

runway, since this is a nested type, we'll say ControlTower.terminal.

Okay, let's go back down.

There's an error and that's because I need to return the terminal.

Take a step back and inspect your code.

Make sure you really understand things because

we've pretty much implemented all the logic for our control tower

by relying on the information encoded in the Airline protocol.

We do have enums that indicate what different airlines we can expect to land,

but we didn't need to create an instance of,

say, domestic airline to get this to work.

But finally, with all of this out of the way,

let's now focus on creating the type that we will be interacting with primarily, so

the domestic airline and international airline.

Note that I'm not going to implement the private airline for

this example because it's more or less identical.

So down below the control tower, let's create a new type.

We'll say struct DomesticAirline and

remember all our airlines conform to the Airline protocol.

So we'll say Airline and open up the body.

For this narrow example,

all we need to conform to Airline is to implement three things.

So we need the descent speed, which we'll make a constant.

We need the type, which is also constant.

And finally, we need a single method which is requestLandingInstructions.

Now the body of this method is all too simple, all we're going to say is return

ControlTower.land, and we'll pass in self.

So over here, we're just asking the ControlTower for landing instructions.

Whoops, we need that, there we go.

Now similarly, we could implement the international flight type,

but that's not even necessary because it's almost identical.

We can change this name and it's exactly the same.

Most of the work is being done by the Airline protocol,

so we really don't need to have anything in here.

Ignoring the fact that in a more complex example,

there would be more differences between domestic and

international flights, in our case it's nearly identical.

I could change the struct name like I just mentioned, and

we really wouldn't have to change anything else.

This indicates, if you think about it, that we may not even need these types.

We may not need DomesticAirlines and InternationalAirlines separately.

Let's take a break here.

And in the next video, we'll explore how protocols can help the situation further.