[MUSIC]

Now that we have some data to work with, we want to create a collection that we can

use for loops and perform some additional functionalities.

For the looping capabilities, PHP offers us an iterator interface, so

we don't need to create our own.

Often, when working with interfaces,

you will use existing interfaces such as the iterator.

Besides the interfaces that are built into PHP,

most frameworks include their own interfaces.

These interfaces work as a kind of guaranteed documentation for

using individual components.

By combining multiple interfaces, we can build powerful components

that can be easily understood by the rest of our application.

Let's go back into our collection file.

We are going to use implements Iterator.

This implements the built in iterator interface.

This implements keyword is how we specify that our class

will meet the contract of a given interface.

We add the name of the interface and

then it's up to us to implement the details of that interface's methods.

Somewhere in this class, I mentioned that we can combine interfaces together

to give our class more and more capabilities.

We can do that by adding more interface names separated by comma.

So for this example, we also want the collection to be countable, so

we can add a comma and then the built-in Countable.

We'll use two properties,

protected $repo; and a public $collection;.

Then we'll set up a construct.

On construct, we're going to pass the $repo and

optionally the ID and field if we want to limit our collection.

We don't care where the data is coming from, but we do need to know that we can

access the find and all methods that we set up in our repository interface.

Type declarations, also called type hinting,

allows us to require a specific type of parameter on a method call.

Type hinting for classes and

interfaces was added in PHP5 along with arrays and callable.

PHP7 added scaler type hints.

These are the basic variable types of Boolean, float, integer and string.

To specify that our first parameter must

implement the repository interface,

we specify the name of the interface before the parameter,

public function __construct(

RepositoryInterface, and then $repo,

then we can add our optional parameters,

$id = null, $field = 'id').

On construct, we first set the local $repo,

then we populate our collection $this -> repo = $repo; if the ID is not empty.

Then we're going to say $this ->

collection = $this->repo-> find(.

We're going to past posts,

the ID and the field.

Else.

$this->collection = $this->

repo->all('posts');.

Now we need to implement the methods from the iterator and countable interfaces.