Referring to Parents, Final

We begin today by continuing our discussion of how classes in PHP work that we began on Monday.

Consider:

class A {function foo(){} }
class B extends A {function foo(){} }

Within B, self::foo() refers to the redefinition of foo given in the second line above. (Instance methods can also be called using $this->method())
Within B, parent::foo() refers to class A's version of foo.
To prevent a function from being overridden in a subclass you can use the keyword final.
```
class A {final function foo() {} /* can't override*/ }
```

Namespaces

Like C++, PHP supports a notion of namespace. This is similar to the Java notion of package. It allows one to group together a collection of functions, constants, classes, interfaces under one name.
Namespaces must be declared at the start of the file they are in (only the declare command can occur earlier)
A namespace might be declared with a line like:
```
namespace TheNameOfMyNamespace;
// code for namespace
class A
{
  //code for class A
}
function foo()
{
}
```
This declaration with the same name can be at the top of multiple files if you would like to group the contents of these files into the same namespace.
A sub-namespace of a namespace can be declared using backslashes:
```
namespace TheNameOfMyNamespace\MySubNameSpace;
//code
```
Within one file you can switch what namespace you are defining, but it is not recommended:
```
namespace D {
  // code for D
}
namespace E {
  // code for E
}
```

Using Namespaces

Function or class names without qualifications are assumed to come from the current namespace:
```
namespace N;
function foo()
{
  //some code
}

foo(); //assume N namespace.
```

Before function, interface, class, or constant names we can also give the namespace path (either relative or absolute):

M\foo(); /*in context of above we are in N namespace already, 
          so M\foo() means the foo() in N\M namespace. */
\N\M\foo();
\time(); //time function in the global (default) namespace.

You can import a namespace using the use keyword:

use A\B\C;
//rather that type $a= new A\B\C(); you can type $a= new C();
use D\E\F as G;
//rather than typing D\E\F\goo(); could type G\goo();

Namespace Conventions

When you create a new project you don't want to pollute the global namespace with your variables, functions, and classes.
Doing so prevents your code from inter-operating with other PHP code.
The modern way to create PHP projects is to write your project within a namespace of the format: some_vendor_name\some_project_name.
For example,
```
namespace seekquarry\yioop;
```
Following this convention, the above declaration should be at the top of a file with at most one file level comment at above it.
You can of course declare instead sub-namespaces of the project too such as:
```
namespace seekquarry\yioop\models;
```
After the declaration, you should have a blank line followed by any use declarations you need.

In-Class Exercise

Create a class some_company\some_project\StringHolder with a constructor which take a string $a_string and stores in into a field variable $my_string.
In a separate file require_once your class.

In this same file have a line:

use some_company\some_project\StringHolder ;

Then create an instance of StringHolder using the line and echo $my_string:

$string_holder = new StringHolder("hi there");
echo $string_holder->my_string ."\n";

Run your program to verify using namespaces works correctly.
Post your solutions (code plus test run) to the Oct 19 In-Class Exercise Thread.

Autoloading

The require and require_once commands read in the file given as their argument regardless of whether the classes, functions, etc. are ever used.
In a web and interpreted environment this can result in slower performance, if there are a lot of files being included in this way.
On the other hand, a use declaration does not load anything into memory -- it just declares a naming convention to be used for how to refer to classes and functions.
In PHP, we can use the spl_autoload_register($your_autoloader_function); command to register a PHP function to be called when someone tries to instantiate a class or call a function which is not currently in memory.
Using autoloading, allows us to minimize the number of files we read in before executing code.
The autoloader function typically makes use of the namespace info from use declarations to search the file system to find the definition of the class or function that is being instantiated or used.

More Autoloading

To demonstrate autoloading, I'm going to discuss the Yioop search engine software that we've been using for the class discussion board...
The Yioop search engine can either make use of the autoloader that it comes with or it can use Composer's autoloader.

The code to check which to use and the native autoloader are in YIOOP_FOLDER/src/configs/Config.php. and looks like:

if (file_exists(__DIR__."/../../vendor/autoload.php")) {
    require_once __DIR__."/../../vendor/autoload.php";
} else {
    spl_autoload_register(function ($class) {
        // project-specific namespace prefix
        $prefix = 'seekquarry\\yioop\\tests';
        // does the class use the namespace prefix?
        $len = strlen($prefix);
        if (strncmp($prefix, $class, $len) !== 0) {
            $prefix = 'seekquarry\\yioop';
            $len = strlen($prefix);
            // no, move to the next registered autoloader
            if (strncmp($prefix, $class, $len) !== 0) {
                return;
            } else {
                $check_dirs = [WORK_DIRECTORY . "/app", BASE_DIR];
            }
        } else {
            $check_dirs = [PARENT_DIR . "/tests"];
        }
        // get the relative class name
        $relative_class = substr($class, $len);
        // use forward-slashes, add ./php
        $unixify_class_name = "/".str_replace('\\', '/', $relative_class) .
            '.php';
        foreach($check_dirs as $dir) {
            $file = $dir . $unixify_class_name;
            if (file_exists($file)) {
                require $file;
                break;
            }
        }
    });
}

Comments on the Yioop Autoloader

Notice the native autoloader gets a string name of the form some_namespace\class. The above autoloader checks if the namespace begins with seekquarry\yioop. If it doesn't then it returns -- it doesn't know how to autoload it.
Otherwise, we take the portion of the name after the vendor\project, $relative_class. For example, \seekquarry\yioop\models\Model, has $relative_class as \models\Model. We convert backslashes into forward slashes and tack on .php. Then we look to see if either of the files BASE_DIR . $relative_class or WORK_DIRECTORY . /app$relative_class exist and if so load it. I.e., in our example, we check for BASE_DIR . /model/Model.php and WORK_DIRECTORY/app/model/Model.php
For us to find the class we want, we need to follow the convention that a class is always defined in a file with the same name and in the appropriate relative folder.
The Composer project also follows this convention.

Finish Classes, Namespaces, Autoloading

Outline