1. T3X_sl_zendframework-1_9_5-z-200911181108
2. T3X_slmvchelper-1_0_0-z-200911180116

In one of my previous posts I showed you how to implement the Zend_AutoLoader in your normal PHP project to save your self some time and to make you stop carrying about if a class is loaded all ready or has to be required. Wouldn´t it be nice if one has Autoloading inside Typo3 too ? Well this can be done quite easy. First of all you will have to install the sl_zendframework Extension into your typo3.

This will provide two things to you.

First of all you will be able to use all the nice things the Zendframework delivers at the version 1.9.5 (except zend_locale, zend_gData, and zend_codegenerator those where removed because of size issues). The second advantage you will get is worth even more, you will have lazy loading via autoload.

By default this extension provides the autoloading for all Zend related classes you might need in your extension. The only requirement is that it is installed and loaded before your own extension. You are able to check that in the localconf.php by the order of $TYPO3_CONF_VARS['EXT']['extList']. The sl_zendframework extension has to stand at a position in that list that is before the position of your plugin.

The sl_zendframework will also provide you with the variable $autoloader inside the ext_localconf.php file of your extension witch is a singleton instance of Zend_Loader_Autoloader. This will be the base to get your extension to autoload what is inside,… or even if other extensions use this too, what is inside them too.

The way to achieve this is quite simple:

/**
 * this is the path to typo3conf/ext,
 * or if the extension is installed global typo3/ext
 */
$s_include_path = str_replace('yourExtensionKey/',
                    '',
                    t3lib_extMgm::extPath('yourExtensionKey'));

/**
 * now we add the path to the extensions
 * parent folder to the includepath list
 */
set_include_path(get_include_path() .
                          PATH_SEPARATOR .
                          $s_include_path);

/**
 * now we register the name of the extension as
 * a namespace for the autoloader
 */
$autoloader->registerNamespace ( 'yourExtensionKey' );

After you added those lines to your ext_localconf.php you can almost forget about include and require statements, as long as the class you want to
instanciate is inside your extension folder and prefixed with name of your extension, witch you just registered as a namespace to the autoloader.

Let me show you some examples:

 // file inside  a folder with the name "yourExtensionKey"
 // carrying the name yourClassName.php
 $instance_1 = new yourExtensionKey_yourClassName();

 // file inside  a folder with the name "subFolderName"
 // inside the folder "yourExtensionKey"
 // carrying the name yourClassName.php
 $instance_2 = new yourExtensionKey_subFolderName_yourClassName();

No more require_once needed because the zend_autoloader will do the job for you. Now that I have showed you how to get the autoloader up and running for your extension, let me introduce you to the second extension “slmvchelper”. This extension can be called the result of working with typo3 for several years now (in 2010 it be my 7th anniversary of working with typo3). As I mentioned before I am a little bit lazy when it come to writing code, so I try to save myself as many lines as possible, and try to keep it as simple as possible if someone else or even me myself has to edit a extension I have done. This is way I came up with the idea of the two classes this extension contains (as well as a example pi1) by the start of 2009.

The first one helps you with the template parsing and all the methods one has to use during the development of a extension to get his template parsed and displayed. It is called “slmvchelper_view_templateParser”, and yes if you install the extension on your system it will register it self to the autoloader so that you can use it by this simple line of php:

  $this->view = new slmvchelper_view_templateParser($this);

After that you will have an instance of the Templateparser witch provides you with some simple methods to make your live easier while developing extensions.
But step by step.

Next thing you will have to do is this:

  $this->view->setTemplate($this->conf['template.']['path']);
  $this->view->setSubPart($this->conf['template.']['mainSubPart']);

The “setTemplate” method excepts a string witch leads it to the template file you want to use. In this case this would be provided in plugin.tx_slmvchelper_pi1.template.path and is something like “EXT:slmvchelper/static/html/template.html”. After the call the template
will be loaded. Next thing to do is to set the main Subpart of the template you want to work with. Same here, it is provided in plugin.tx_slmvchelper_pi1.template.mainSubPart and is something like ‘TEMPLATE_MAIN’. The setSubPart method exepts two parameters, the first one is mandatory because it is the subpart you want to declare, the second one is optional because it is the parent subpart of the subpart to declare. So if you want to work on a subpart within another one you would do something like this:

  $this->view->setSubPart('SUBPART_TEST', $this->conf['template.']['mainSubPart']);

Witch would mean you are declaring the subpart named “SUBPART_TEST” inside “TEMPLATE_MAIN”. After you have done this you might want to set some markers and parse the whole stuff and return it. This is also quite easy:

  $marker = array(
		'NORMAL_MARKER' => 'Hallo Welt'
  );

  $subparts = array(
		'SUBPART_TEST' => $this->view->parse($marker, array(),
                                                'SUBPART_TEST')
  );
  $content = $this->view->parse($marker, $subparts,
                                           $this->conf['template.']['mainSubPart']);

By now you might have recognized that those three “#” are missing at the marker name as well as at the subparts name, this is they are no longer required inside your php code, they will be set automatically by the template parser inside the method parse(). I think the first and the second Parameter should be quite obvious, and the third should be no that hard to guess. Right, the third param of the parse method is the name of the subpart you want to use for parsing the values. So for the subpart ‘SUBPART_TEST’ this would be ‘SUBPART_TEST’ and for the template it self this would be $this->conf['template.']['mainSubPart'] or TEMPLATE_MAIN. This is it, to my mind the easiest way to get your template parsed and displayed.

But wait there is more:
The templateparser also provides you with some markers that are there by default. You can access everyting inside your locallang file by simply adding the marker ###LL_yourLocalLangKey### to the template, it will be parsed automatically and add the value of “yourLocalLangKey” to your template, and you do have also every public member variable of $this->cObj->data available by simply adding ###COBJDATA_nameOfTheMember###. So for instance ###COBJDATA_uid### will display the uid of the tt_content element witch is stored inside $this->cObj->data->uid.

The second class of the “slmvchelper” extension is called “slmvchelper_model_base”, witch will provide to you a light version of extBase witch comes with typo3 4.3 this winter. The “slmvchelper_model_base” class gives you the opportunity to simply read and write data to your database. All that is required is for you to set up a model witch has all the fields of your database table as member variables as well as you have to set the table name to work with inside the constructor of the model.

Your model should be looking something like this:

  class yourExtensionKey_model_databaseTableName extends
  slmvchelper_model_base{
	protected $uid;
	protected $pid;
	protected $text;

	public function __construct()
	{
		$this->setTable('tx_yourExtensionKey');
	}

	public function setUid($uid)
	{
		$this->uid = $uid;
	}

	public function getUid()
	{
		return $this->uid;
	}

	public function setPid($pid)
	{
		$this->pid = $pid;
	}

	public function getPid()
	{
		return $this->pid;
	}

	public function setText($text)
	{
		$this->text = $text;
	}

	public function getText()
	{
		return $this->text;
	}
}

Remember we got autoloading so now we can go on in the pi1 for instance with:

  $o_newRecord = new yourExtensionKey_model_databaseTableName();
  $o_newRecord->setText('Hallo Welt');
  $o_newRecord->save();

What just happened is that we inserted a new Record into the database. That simple. After the save() $o_newDummyRecord provides you with $o_newDummyRecord->getUid() witch will return the uid of the record we just inserted.

If you want to read a simple record from the Database the code would look like this:

  $o_newRecord = new yourExtensionKey_model_databaseTableName();
  $o_newRecord->setUid(1);
  $o_newRecord->getThis();

If you want all records that contain the string “Hello” ordered by sorting this would be your code:

  $o_newRecord = new yourExtensionKey_model_databaseTableName();
  $o_newRecord->setText('Hello');
  $result = $o_newRecord->getAll('sorting');

In this case $result would contain an array of yourExtensionKey_model_databaseTableName objects filled with the data of each record.
Even getting querys build like (hidden = 0 AND Deleted = 0 AND (starttime = 0 OR starttime < time()) AND ((endtime = 0 OR endtime < time()))
is possible.

Just like this:

  $o_newRecord = new yourExtensionKey_model_databaseTableName();
  $o_newRecord->setText('Hello');
  $o_newRecord->setHidden(0);
  $o_newRecord->setDeleted(0);
  $o_newRecord->setStarttime('=_0_>=_'.time());
  $o_newRecord->setEndtime('=_0_<=_'.time());
  $result = $o_newDummyRecord->getAll('sorting');

In this case your model should contain the member variables deleted, hidden, starttime and endtime as well as their getters and setters.

All of this you can see in action if you install the sl_zendframework and the slmvchelper extension to your typo3 and put the pi1 of slmvchelper in one of your pages. It will show you a simple example, and if you look inside the pi1 file you can see a little summary of this tutorial working.

I hoped you enjoyed my tutorial and feedback would be appreciated.

But back to the topic of this post,.. I came across the new Autoloader Class provided with the Zend Framework, studied some of the documentation. And Failed,.. perhaps I over-read something but where does the documentation mention that your class has to be prefixed with the name of the namespace one registers ?

But one by one, if you like to use the autoloader either with your extension to the CM-System of your choice (in my case this would be Typo3 at 90% of the projects I work on), or within some php-code you write for a customer, you will have to start wit something like this:

  set_include_path ( '.' . PATH_SEPARATOR . 'path/to/Zend_Framework/' );

  require_once 'Zend/Loader/Autoloader.php';
  $autoloader = Zend_Loader_Autoloader::getInstance ();
  $autoloader->setFallbackAutoloader ( true );
  $autoloader->registerNamespace ( 'nameOfYourNameSpace' );

This was how far I got with the documentation. Because I know some other languages like JAVA, I knew that I would have to create a nice little sub folder called “nameOfYourNameSpace” in the directory for a SOAP – Client I lately wrote for a customer of mine. I went on creating the class file I needed:

  class myClass
  {
     public function __construct()
     {
        // here the code Starts
     }
  }

Like I said I am used to the conventions of other languages when it comes to namspaces, so I called the file myClass.php. Now in my imprudence I thought something like this would work right from the Start, as well as I am getting rid of those require_once statements:

  $o_myObject = new nameOfYourNameSpace_myClass();

Hhmmm,… nope it doesen`t,… turns out that the class within the file has to be prefixed by the name of the namespace it self. So I had to change the php class to this:

  class nameOfYourNameSpace_myClass
  {
     public function __construct()
     {
        // here the code Starts
     }
  }

After that, the first code segment worked fine for me, and I had a nice little autoloader to load my models. Is it just me, or would you too have expected that it should be enough to create the folder structure registered in the first snippet and call the class just like the file name ?

Perhaps this was a little help for you getting to know the Zend_Loader_Autoloader.
Drop me some thoughts if you like.