PHP 5, Factory

I will try during this tutorial to explain various techniques introduced in PHP 5 that I like to use (or I would like).
The reason?
Next time I'll need something like that I can find it quickly and get documented with the information necessary, given that at some point i'll lose these things through a corner of the HDD.

I. Definitions

I'll try to respect the rules exactly as published under the name of Coding Standards on the PEAR website.
The "inline" classes, methods and attributes documentation is very useful when I read the source code of a file written six months ago.
I usually use phpDocumentor to generate php code documentation professionally.

II. Intro

The first example presented in this series refers to the concept of factory implementation in php. This example is not complete and can not be considered a standard example of the "factory" idea.
To answer my questions "What is a Factory?", " At what does it helps me?", "Is it useful?", "is it worth it?" i read the article "The Factory Method" by Harry Fuecks.

I read carefully the code posted there, and I read these pages that are part of the presentation "2002 International PHP Conference: Applied OO PHP: APIs, Design Patterns and Useful Objects - Chuck Hagenbuch.
Google also brought me some interesting articles.
Finally, I decided to implement an example written in Java.
For testing, i'll use php CLI and a directory called trace_factory.

III. Interface.

From the documentation in hand, through an interface we can create an object that specifies which methods a class must implement, without defining the behavior of these methods.
Translation of Java in PHP 5 interface looks like:

I saved this file: ITrace.php name.

Continuing the example, we will write two implementations, in the first, the messages will be displayed in the console (or in the web page if we drop CLI ) and the second it will write the messages to a text file.

IV. StdoutTrace.php

I saved the file with the name StdoutTrace.php the same directory.

V. FileTrace.php

I saved the file with the name FileTrace.php the same directory.

VI. Factory

Saved with the name TraceFactory.php 

VII. Some explanations

Before going further, I think it's time to explain what I did before. I tried to implement in PHP 5 a factory model taken from an example given in java.
In Part I, we wrote an interface containing three methods:

• setDebug($debug), which will allow me to change the leve displayed by the trace (debug or error)
• debug($message), i could display a debug message (of course if I did setDebug(true) in advance).
• error($message), it will display an error message all the time (regardless of the value set for $ debug).

In the second part, as in the example which I followed, I implemented the Itrace interface two cases, FileTrace that will allow me to save the messages/errors to a text file named StdoutTrace and that will allow me to show these messages in the console (web page).
Mandatory the two new items will have to implement the interface methods presented in ITrace.
FileTrace, in the example followed by me, had to throw an exception in the constructor. We decided that if the file that I want to log messages into does not exist or it can't be written into it, i'll throw exception, but if everything is OK, i'll create the handler.

$this-> handler = fopen($file, "a+")

We decided to open the file in a+ (read/write, like the file pointer at the end of the file), although it was probably enough (and do not intend to read the file).
In addition to the following example, I wrote a destructor, but it was not necessary (PHPwill automatically terminate upon completion handler code execution?) and provided:

if ($this-> handler === true)

I think it's pointless (maybe something else is going in $this-> handler =fopen ($file, "a+") ?).
I decided to replace the attribute in PHP:

private java.io.PrintWriter pw

with $handler, and found that in PHP if you want to write something in a file is more intuitive and easier to remember.
Comparison:

pw = new java.io.PrintWriter (new java.io.FileWriter ("c:\trace.log")) (not very easy to retain this line)

with

$this-> handler = fopen($file, "a+");

the builders, or how to write (for example):

pw.println("DEBUG:" + message);
pw.flush() (??)

with

fwrite ($ this-> handler, data ("dmY H: i: s"). "DEBUG>>>>". $message. "\n");

But that is another question.
For greater flexibility, we decided to name the log file messages have to be passed in the constructor (like I want to go on linux and windows in the same manner, not using a default file name: c: \trace.log).
This brings direct changes to factory .
In contrast, In StdoutTrace things are pretty clear, just like in the example, except that the object name shown in the example (SystemTrace), I replaced it with StdoutTrace.

I will continue TraceFactory explanations.
Just as in this example, I declared the method as static, plus adding $file parameter, representing the file name in that you log messages.
I used a block try/catch to intercept the exception thrown by the manufacturer of FileTrace.
Perhaps the meaning of the example was changed when I decided to pass the file name where the log is done.
As a small translation, i'll try (try) to return a new instance of the object FileTrace, if i fail it (catch), initialized StdoutTrace that will surely go, having in this way the possibility to display error messages / debug.
In the next one to try and implement this example, although now it is quite intuitive.

VIII. An implementation

I wrote the RunTrace.php file:

After execution, the console was the result:

And I have the file logger.log :

If i comment the line:

touch($filename);

and delete the file logger.log, the result will be (OK, only the console, because the manufacturer of FileTrace will throw the exception because the file does not exist):

$ php runTrace.php

However, i'm not satisfied with the written code, and more, passing the $file as a parameter in factory, and as a default the constructor FileTrace i got to far from the example from which we started.
I'll try to rewrite FileTrace and TraceFactory to reach the usefulness and the conclusions presented in the following example:

IX. Some corrections

As I said at the end of last chapter, I decided to rewrite TraceFactory and FileTrace to be closer to the model followed.

FileTrace.php

TraceFactory.php

X. Other explanations

I tried to get as close as posible to the example I followed.
Rather, the manufacturer of FileTrace could be rewritten as:

However, on windows would be more difficult to test, but there should be no concerns about the fact that I could not create the file logger.log. On linux, taking into account the permissions that must be set for the working directory should still be possible.

XI. Another implementation

I rewrote the mini runTrace.php test as follows: