Classes in PHP

Classes in PHP can be defined with a syntax like:

class MyClass
{
   public $field_var1;
   public $field_var2 = 5;
   ...
   const $constant1;
   const $constant2;
   ...

   function __construct($arg1, $arg2) {
     //constructor code
   }

   function myFun1() {
     // code
   }
   ...
}

Traditionally, you put the code for your class into a file and then use a line like:
```
require "MyClass.inc";
//or more likely
require_once "MyClass.inc";
```
We will discuss a more graceful way to load class definitions known as autoloading after we finish talking about classes and namespaces.
The require function gives a fatal error if the class cannot be found. Also you cannot use require to include remote files even if allow_url_fopen is enabled.
require_once will not re-include the file if it has already been included.
PHP comes with several built-in classes and interfaces.
Several common data structures are also implemented in the Standard PHP Library (SPL).

Constructors/Destructors

We can set up an initial value of a field variable of a class when we declare it:
```
public $my_variable = 0;
```
You can also have a functions __construct and __destruct to do initialization and clean-up.
```
function __construct($n=0) 
{
     $this->my_variable = $n;
}
```

Private, Protected, Public

Member variables and member functions can be declared private, protected or public:

public $my_field1;
var $my_field2;
private $my_field3;
protected function myMethod() { /* some code*/}

Methods without any declaration are the same as public. Fields declared with var are also public.
private means only visible within the class.
protected is visible within the class or within subclasses.
public means the variable or method is visible to anyone within the namespace. The PSR-2 coding guidelines prefer using public over var for field declarations.

Static and Const

The static keyword creates one instance of the field or method for the class.
```
class Foo{ static $bob=1;} 
echo "bob: ".Foo::$bob;
```
Within the class use self:: to refer to static members.
The const keyword can be used to define constants for a class:
```
class Goo{ const BLOB=1;}
```
Notice no dollar sign. Can refer to this using
```
Goo::BLOB
```
Values of constants cannot be changed.
You can create constants outside of any class using the define keyword. For example,
```
define("PI", 22/7);
echo PI;
```

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 than typing A\B\C\foo(); could type foo();
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-namespace of the project to such as:
```
namespace seekquarry\yioop\models;
```
After the declaration, you should have a blank line followed by any use declarations you need.

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 is 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 whether 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.
The Composer Project makes extensive use of autoloading and is used to build projects using Yioop as a library.

More Autoloading

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 number and in the appropriate relative folder.
The Composer project also follows this convention.

Composer

Composer is a package management system for PHP. It is similar to npm for Javascript or pip for python. It was initially developed in 2011.
It lets people combine various PHP projects, making sure that the dependencies between the current project and different versions of the projects it depends are maintained.
A large list of projects that can be used with Composer can be found on the site: https://packagist.org/.
Yioop is one such project.

Composer

The Composer site has instruction for downloading and installing composer.
Once it is downloaded, you can run it from the command line with a line like:
```
composer some_directive_for_composer
  
```
A composer project has at a minimum a composer.json file, and a sub-folder labeled vendor.
The composer.json file is used to specify what version of which projects your project depends on.
The vendor folder is where Composer downloads and stores the correct versions of these projects.

An example composer.json file suitable for working with Yioop is:

{
    "name": "your_vendor_name/your_project",
    "description": "put what your project is about here",
    "authors": [
        {
            "name": "Your Full Name",
            "email": "Where@to_contact.you"
        }
    ],
    "config": {
        "secure-http": false
    },
    "require": {
        "seekquarry/yioop": ">=3.3.0"
    }
}

Example Composer Project Using Yioop

Once you've created a composer.json file and a blank vendor directory, you can start coding your project.
Typically, if you are using a version control system you add the vendor folder to your ignore list for the system. For example, with git, you might add the vendor folder to the .gitignore file.
In a standard project organization, you might then have an index.php file in the root folder of your project, have a src folder with the src code of your project and have a tests folder with any unit tests.

To keep things simple for our first try, we just put the following in our index.php file:

namespace cpollett\test_composer;

use seekquarry\yioop\configs as SYC;
use seekquarry\yioop\library as SYL;
use seekquarry\yioop\library\PhraseParser;

require_once "vendor/autoload.php";
print_r(PhraseParser::stemTerms("jumping", 'en-US'));
echo SYL\crawlHash(SYC\NAME_SERVER . "1234");

Then to get Composer to install Yioop under the vendor folder and create an autoloader for the projects that were needed, we might type from the project directory:
```
composer install
```
If you want to update composer projects later you type:
```
composer update
```
After which, we can run our program with the command:
```
php index.php
```
to execute out project. It should output:
```
Array
(
    [0] => jump
)
joQWpC4Sdy4
```

Comments on the Example

The example above illustrates using Yioop's PhraseParser class to do stemming.
This class can be found in the file YIOOP_FOLDER/src/library/PhraseParser.php.
This file has other useful methods for doing char-gramming, segmenting, and primitive detection of bad words.
Another file in the library folder, Utility.php contains lots of useful functions such as the crawlHash function illustrated above. For example, this file is where the functions for compressing/decompressing postings in Yioop are located.
We will continue our discussion of the organization of things in the Yioop project as the semester progresses. But now we return to talking about building inverted indexes, after this short break.

More PHP, Stop Words and Unicode

Outline

Introduction

Classes in PHP

Constructors/Destructors

Private, Protected, Public

Static and Const

Namespaces

Using Namespaces

Namespace Conventions

Autoloading

More Autoloading

Comments on the Yioop Autoloader

Composer

Composer

Example Composer Project Using Yioop

Comments on the Example

In-Class Exericse