While parts of the world are still freezingly cold, Taipei is already slowly warming up to 21 degrees, blue skies and sunshine. Sadly enough as this is my last day in the city for probably a very long time. Tomorrow I will fly off to a new life in the old country. After twelve years of travelling all over the island this place really feels like home.

Today was also the last day that I could take the second and final part of the MySQL 5.0 Developer certifications. The US$ 200 SUN exam voucher I had purchased earlier is only valid in Taiwan. Taking the exam in the Netherlands was thus not an option.

Looking back at my previous blog entry about the MySQL Examens — it took me 20 days to prepare this part of the exam. I studied by browsing through the exam book at breakfast and before going to bed and added some more serious study blocks to work through all the exercise questions.

The second exam was quite a bit harder than the first one mostly because it asked many interesting (and confusing/tricky) questions about inner, left and right joins and of course sub-queries.

But what I found the hardest chapter in the book Chapter 18. Stored Procedures and Functions in which a complete programming language is introduced using only about 2-3 examples was good for only a few questions. Just pay attention to the correct syntax.

Overal I really enjoyed studying for the exam. The MySQL exam preparation book is excellent and covers the exam exactly.

MySQL Certified Developer 5.0 Part II is a post from: Martijn's PHP Coding Blog

As promised in my last post (twenty days ago — life has been busy!) I am working through the MySQL Developer 5.0 examinations. I have just completed the first of two exams and I am trying to find time to cram for the second exam.

There are plenty of changes going on here — the original exam MySQL exam provider was changed this year from Pearson Vu to Prometric as Sun Microsystems acquired MySQL.

And now of course Sun is in limbo as it in turn is being acquired by Oracle — a deal being blocked in Europe because of , yes :  MySQL. For a by the minute discussion of what is going on there just keep track of the postings at Planet MySQL.

Expect many FAQ’s to be out of date. It is better to check the MySQL Certification forum for the latest changes. The person to note is David Stokes who is the MySQL certification manager and who posts regularly to this forum.

How to study for the exam?

There is only one book which you are going to need — and that is the “MySQL 5.0 Certification Study Guide” (Paul DuBois, Stefan Hinz, and Carsten Pedersen, ISBN 0-672-32812-7) (link). The book itself is split into 4 sections, as there are four different exams.

• MySQL Developer I & II
• MySQL Database Administrator I & II

Besides the book you are also going to need a laser printer and a big stack of empty sheets.

On the CD with the book there are four more PDF’s with Exam study guides. First study the book, then print the PDF’s and work your way through the exam preparation questions. This is not optional, the preparation guide touches on many things that are explained briefly in the book — but will catch you off guard if you don’t work through the very pointed questions.

The book itself is excellent, concise and to the point and after reading it I really felt that I was ready for the exam.

How to book the exam?

To book the exam you need to buy vouchers for the exams from your (national/local) Sun Microsystems branch. For me that was Sun Taiwan. I wrote them an e-mail in English and they quickly responded and helped me with buying the correct vouchers. Great service.

As I mentioned earlier — the MySQL Developer exam is split into two parts. Each part sets you back a whopping US$ 200 and you need to complete both parts to become certified.  There is some confusion about the exact price of the exams. Some of the documentation in Taiwan mentioned US$ 300 per exam, but in the end I paid the Taiwan dollar equivalent of US$ 200.

Now with the vouchers in hand you can book the exam through the Prometric website, the correct codes for the exams are:

Company: Sun Microsystems 310-Series.

• 310-812 Dev 5.0 I
• 310-813 Dev 5.0 II

What to expect at the exam

I had booked the Prometric exam at a Taiwan government institute in central Taipei. This place is setup for exams and I was not the only person taking an exam this time. I brought the required 2 sets of ID and made sure I carried as little as possible as it all had to fit into a small locker. (No need to cram anymore, right?).

The only gotcha was that they needed my Prometric ID number which I didn’t know and which wasn’t mentioned in the e-mail when I made the booking. A quick check of the Prometric website at a nearby computer (what WAS that password again?) helped me out there.

The exam itself was in exactly the same format as the Pearson Vue PHP Zend exam. Multiple choice questions on a computer screen. I needed about an hour to work through the 70 questions, giving me another 30 minutes to look again over the questions I had marked for review.

Press the “really, really sure” button ; en pick up your score card at the front desk. And of course realise that you have to do this one more time.

Preparing for the MySQL Developer examinations is a post from: Martijn's PHP Coding Blog

taipei 101 by orange tuesday @ flickr

I have been busy these last couple of weeks preparing for the Zend Certified Engineer / PHP5 exam. Although I have been using PHP for years – I never had a need to “prove” this. That might change in a few months as I start looking for a new job. Doing the Zend exam in preparation of this sounded like a good start. My first step was to order the Zend PHP5 Certification Study Guide by Davey Shafik and Ben Ramsey from Amazon.

The difficulty is not so much in the technologies — most things in PHP are very straightforward — but the sheer scope of what PHP covers and the potential for in dept questions. The exam covers programming basics such as converting hex / octal and decimal, XML & XPath, Web programming, OOP, Databases, Pattern theory etc. The study guide covers most topics but it alone is not enough to pass the exam. It will set you on the right path — but you really need to dive deeper.

After reading the book once or twice, doing the PHP | Architect Vulcan mockup exam (which costs just a few US$ per try) is really a required next step. If after reading the book you are still happy in theory land — the mock exams quickly bring you back to the nitty gritty of PHP programming. Yes, its all trick questions about code, php.ini settings, code examples (was that &$var or $var?), cross site scripting and otherwise suspiciously real fake code.

I booked the exam for this morning and the nearest Vue Pearsons exam was at the Chunghua Telecom Corporate University (which is the training centre for Taiwans state run telecom) in Taipei.

This is the district that as a foreigner in Taiwan you visit every few years to extend your resident visa. Past the old visa office, the firebrigade and police station is a big Chunghua compound. The guards were a bit surprised to see me but a little Chinese goes a long way.

No long queues of people taking exams — the exam room was unlocked for me and I had a cup of coffee while two friendly admin ladies/supervisors setup the exam. All the forms are in Chinese — but they managed to dig up an English version from somewhere.

The exam is very much like the mock exam — having done the mock exam twice I didn’t feel pressured by the ticking clock.

The VuePearson software is a bit slow, and not free of bugs. (Two exam questions were unreadable dumps of what looks like RTF so I had to skip them). I noted both questions to the supervisors. Expect many trick questions — and some very detailed questions about basically anything covered by PHP.

With plenty of time left I reviewed all questions one more time — and probably increased the number of mistakes — and then pressed the big “end of exam” button.

Result? Of course it was a pass — the paper I received at the end tells me this — if I failed I would be back at square one.

The only question I had as I left the exam centre was : what kind of grades are there? The mock exam has fail/pass and excellent. The real exam only pass/fail.

The VuePearson website lists my results as “processing” .. so I will check back later to confirm that I have been added to the list of Zend exam survivors as #12562.

Next up in my list of things to do are the MySQL Developer exams 1 & 2… After that I might give the Zend Framework exam a try.

My Taipei Zend / PHP 5 Exam Notes is a post from: Martijn's PHP Coding Blog

The code generating the XML was using the PHP function htmlentities to filter its output but this does not generate valid XML. Named entities such as  " and  & need to be represented by their Unicode values:  "  and &

A handy table with all the required replacements can be found at Carlos Ouro’s website.

Below is a simple function that replaces all the named HTML entities found in a string with their numeric HTML/XML counterparts.

Example Usage

XMLEntities function

Fixing htmlentities for xml is a post from: Martijn's PHP Coding Blog

Google Apps has great benefits for small companies. There is little need to maintain your own IT infrastructure, a simple ADSL line attached to a tiny internal network is sufficient for the majority of tasks.

But how do you move an existing company to Google Apps?

A company I have been working with uses Thunderbird for its e-mail.

Moving should have been straightforward as Google provides their own migration tool : the e-mail uploader.

The development of this program however appears stagnant and its bugs are not being fixed. Strange considering how important Google Apps must be for Google.

For me the problem was that 40-50% of the Thunderbird e-mails in the mail store were not being uploaded because the Google Uploader complained that there was something wrong with the date format.

The bug related to this has been open for over a year.

If I wanted to continue I needed to find my own solution or give up on migrating altogether.

A quick browse through the Zend Framework manual showed that it can read MBox files (Thunderbirds mailbox format) through the Zend_Mail_Storage* class and communicate with Google using the Zend_Gdata* classes.

The exercise left was to bind it all together into a working PHP script that would take my mailboxes and upload them to Google.

Having done this and having succesfully uploaded several multi-Gigabyte sized mailboxes I have uploaded my code (‘googlemailappuploader’) to Google Code.

If you find yourself in a similar situation — I hope you find it usefull. Leave me a comment if something is unclear.

Using PHP to upload E-mail to Google App Mail is a post from: Martijn's PHP Coding Blog

Time to debug by henribergius @ flickr

This post contains my installation notes on how to setup the Eclipse PHP IDE with support for XDebug remote debugging in a mixed Windows/Ubuntu development environment.

Debugging PHP with XDebug in Eclipse

The war to decide the best IDE is far from over. If you would like to write PHP code and are looking for a free IDE (Integrated Development Environment) then both Eclipse PHP and the Netbeans IDE are two very strong candidates. Both are written in JAVA. For this post I concentrate on my own favorite: Eclipse. If you would like to compare several other PHP IDE’s then Davey Shafik has a great table comparing IDE features on his site.

Debugging is done through a remote debugger called XDebug. It ties into the PHP runtime on your server allowing Eclipse to communicate with your scripts / web pages. As soon as you start debugging a web page, Eclipse will call your webserver but also pass a couple of parameters. On seeing these parameters (XDEBUG_SESSION_START/KEY), XDebug will start and connect to Eclipse over a TCP/IP connection. From here on Eclipse can control the execution of the script on the webserver.

My development setup

For writing PHP code I use two machines. Windows 7 as my main machine and a Linux server that runs the  LAMP development stack. (If you don’t have two machines available a very good alternative is to install VMWare Player and a Ubuntu Server Virtual Appliance on the Windows machine.) Why two machines? I guess I grew up this way. It is perfectly possible to install Eclipse for Ubuntu and do everything on a single machine.

My Eclipse projects are located on the Ubuntu server through a shared path to my home directory (Z:) on the Ubuntu server.

I can access my work through the webserver as http://development/~martijn by using Apache’s mod_userdir.

Step #1: Download and Install SUN Java & Eclipse

1. Ensure that you have Sun JAVA installed on your Windows machine.
2. Download Eclipse for PHP Developers from the Eclipse download site (http://www.eclipse.org/pdt/downloads/)
3. Untar the tar.gz bundle to a directory on your machine (for example c:\eclipse)

Step #2: Install XDebug on the development server

I assume that you have already installed both Apache and PHP5 on your server. If you haven’t then the following commands will make quick work of this:

# sudo apt-get install apache2 php5 php5-cli

XDebug is installed through the PHP Pear repository, but before this we need to ensure that we have both PEAR and phpize (part of php5-dev) installed.

# sudo apt-get install php-pear

# sudo apt-get install php5-dev

# sudo pecl install xdebug

Now we need to discover where the xdebug.so file was installed by PEAR:

# find / –name xdebug.so

For my Ubuntu server this was:

/usr/lib/php5/20060613/xdebug.so

Create a file named xdebug.ini in /etc/php5/apache2/conf.d, and modify this according to the location of your xdebug.so file:

zend_extension=/usr/lib/php5/20060613/xdebug.so

[xdebug]
xdebug.remote_enable=1
xdebug.remote_handler=dbgp
xdebug.remote_host=10.0.0.2

The above is a very basic setup. The “xdebug.remote_host” is important: it contains the IP address of the Windows development machine. When a web page is called with a special set of parameters XDebug will launch and try to connect to your IDE. Note that the Windows firewall might block Eclipse from listening on Port 9000, if so, then make sure that this port is opened for use by Eclipse.

Restart Apache

# sudo service apache2 restart

We need to test that xdebug was properly installed. Create a small test.php PHP script and place this in your web server root.

<?php phpinfo(); ?>

On my machine I can retrieve this file by calling: http://development/~martijn/test.php. If XDebug was succesfully installed you should see it listed as one of the PHP modules.

Step #3: Setting up Eclipse for debugging code with XDebug

Create a new PHP Project and ensure that the files are in a path that is accessible by the webserver (my Z:\ drive mapping to http://development/~martijn/). If you have done this then you are ready to debug your first PHP code. (You can of course manually copy the files back and forth, but that gets old fast if you do a lot of coding). Start Eclipse, create a new PHP Project and create a little bit of test code. Something like this:

<?php
for ($lp = 0; $lp < 10; $lp++)
echo $lp;
?>

Select Run / Debug Configurations … from the Eclipse menu. Change the Debug Server setting to “XDebug” and ensure that the Default Webserver points to your web directory. In the hope that a picture explains it all click on the screenshot to the right.

Select the line you want the code to stop at (by default it will stop at the first line) and toggle a breakpoint with CTRL-SHIFT-B. Then select Debug (F11).

And that should be it… have fun!

Installing Eclipse for PHP development with XDebug for remote debugging is a post from: Martijn's PHP Coding Blog

Think magic functions, constants, cloning, getters and setters, abstract, final, inheritance, serialization and of course var_export support.

If I missed any concepts feel free to drop a note.

<?php

    /* The Ultimate PHP5 OOP Class
     *
     * Implements most of PHP5's OOP functionality in a single demonstration
     */

	/* PHP_VERSION_ID is available as of PHP 5.2.7, if our
	 * version is lower than that, then emulate it. Some of the
	 * functionality we test here is only available in 5.3.0 and
	 * higher.
	*/

	if(!defined('PHP_VERSION_ID'))
	{
    	$version = explode('.',PHP_VERSION);
	    define('PHP_VERSION_ID', ($version[0] * 10000 + $version[1] * 100 + $version[2]));
	}

    /* Interfaces specify a set of functions that a class MUST
     * implement.
     */

    interface DemoInterface
    {
        public function InterfaceTest();
    }

    /* Abstract classes cannot be instantiated. They define concepts that
     * their derived classes must implement.
     */

    abstract class DemoAbstract
    {

    	/* Constructor
    	 *
    	 */

        public function __construct()
        {
            $this->LogEntry(__CLASS__,__METHOD__);
        }

        /* LogEntry
         *
         * Reports on each methods entry. Defined in the parent class so that
         * we can call it from this constructor as well.
         *
         * @param string	Methodname (from __METHOD__)
         */

        public function LogEntry($methodName)
        {
        	echo "{$methodName} Called" . PHP_EOL;
        }    	

        abstract public function AbstractTest();
    }

    /* The DemoPHP5Class is marked as "final". Because of this selfish act
     * nobody is able to derive from this work and create their own sub class.
     */

    final class DemoPHP5Class extends DemoAbstract implements DemoInterface
    {
        /* Class Constants cannot be changed */
        const VERSION = '1.0';

        /* Private members are only available inside this class */
        private $_className;
        private $_constructorName;
        private $_fileName;
        private $_instanceCount;

        /*  Location for overloaded data. */
        private $_data = array();

        /* As the class is marked final there really is not point in declaring
         * any protected (accessible by derived classes) variables but
         * for good measure we include one.
         */

        protected $_meaningOfLife;

        /* The constructor is labeled as final. Because of this derived
         * classes are unable to implement their own constructor.
         */

        final function __construct()
        {
        	parent::__construct(); 					// Calling the parent constructor

            $this->_className = __CLASS__;          // Magic constants
            $this->_constructorName = __METHOD__;
            $this->_fileName = __FILE__;
            $this->_instanceCount = 0;              // Original, not a clone
            $this->_meaningOfLife = 42;             // No need to say more

			$this->LogEntry(__CLASS__,__METHOD__);
        }

        final function __destruct()
        {
			$this->LogEntry(__METHOD__);
        }

        /* Implements the Abstract members from the DemoAbstract
         * class.
         *
         * @returns string Notification message
         */

        public function AbstractTest()
        {
			$this->LogEntry(__METHOD__);
        }

        /* Implements the DemoInteface
         *
         * @returns string Notification message
         */

        public function InterfaceTest()
        {
			$this->LogEntry(__METHOD__);
        }

        /* Static functions are not part of an instance
         * and can only be called through "classname::staticmethod"
         */

        public static function StaticTest($number)
        {
        	/* Note how LogEntry is NOT static, but we can still call it */
        	/* A warning is generated in STRICT mode					 */
 			parent::LogEntry(__CLASS__,__METHOD__);
        	echo "StaticTest call with ({$number}) succesfull" . PHP_EOL;
        }

        /* Returns the name of the class
         *
         * @returns string Name of the class as discovered by the constructor
         */

        public function GetClassName()
        {
        	$this->LogEntry(__METHOD__);
            return $this->_className;
        }

        /* Set the meaning of life
         *
         * @param   int         Meaning of life
         * @thows   Exception   On invalid input
         * @returns this        Allow for chaining of calls
         */

        public function SetMeaningOfLife($meaningOfLife)
        {
			$this->LogEntry(__METHOD__);

            if (is_int($meaningOfLife))
            {
                $this->_meaningOfLife = $meaningOfLife;
            }
            else
            {
                throw new Exception('Meaning of Life doubted');
            }
            return $this;
        }

        /* Returns the meaning of life
         *
         * @returns int      Meaning of life as a core value
         */

        public function GetMeaningOfLife()
        {
			$this->LogEntry(__METHOD__);
            return $this->_meaningOfLife;
        }

        /* Returns the instance count
         *
         * @returns int 	Instance count
         */

        public function GetInstanceCount()
        {
        	return $this->_instanceCount;
        }

        /* Magic Methods
         *
         * These methods have special meaning inside of PHP5.
         */

        /* Return a string description of the class
         *
         * @returns string  Whatever the class fancies. Usually a description
         */

        public function __toString()
        {
			$this->LogEntry(__METHOD__);
            return '__toString called ; the meaning of life is our domain' . PHP_EOL;
        }

        /* From PHP 5.3.0 its possible to "invoke" a class, using it like
         * a function. Eg. 'DemoPHP5Class(50)'.
         */

        public function __invoke($x)
        {
			$this->LogEntry(__METHOD__);
            echo "__invoke was called with {$x}" . PHP_EOL;
        }

        /* PHP 5 allows the simulation of properties. If a property does not
         * exist when attempting to write the __set method is called giving
         * you an opportunity to handle the variable yourself.
         */

        /* Called when a not-class defined property is set by the user. For
         * example "DemoPHP5Class->FooBar = 500". We add an entry to the
         * $this->_data table.
         *
         * @param   string      A valid name
         * @param   undefined   Any valid PHP value
         * @throws  Exception   Only strings are considered valid names
         */

        public function __set($name,$value)
        {
			$this->LogEntry(__METHOD__);
            if (is_string($name)) {
             $this->_data[$name] = $value;
             return;
            }
            throw new Exception('Invalid Property name');
        }

        /* Called when a not class defined property is retrieved. We
         * attempt to satisfy the called by checking $this->_array.
         *
         * @param    string    A valid name
         * @throws   Exception When the property is not defined
         * @returns  undefined Value of the named property
         */

        public function __get($name)
        {
			$this->LogEntry(__METHOD__);
        	if (is_string($name) &amp;amp;amp;amp;amp;&amp;amp;amp;amp;amp; array_key_exists($name, $this->_data))
                return $this->_data[$name];
            throw new Exception("Attempted to read undefined proporty");
        }

        /* This method is called whenever we try to access an inaccessible
         * property. We check $this->_data to see if a matching key exists.
         *
         * @param   string   A valid string property name
         * @returns bool     True on finding the property in the array
         */

        public function __isset($name)
        {
			$this->LogEntry(__METHOD__);
        	if (is_string($name) &amp;amp;amp;amp;amp;&amp;amp;amp;amp;amp; array_key_exists($name, $this->_data))
                return true;
        }

        /* This method is called when unset is called on an inaccessible
         * class property. We check $this->_data and try to unset it.
         *
         * @param   string      A valid string property name
         * @throws  Exception   The property must exist, mmmm, ok?
         */

        public function __unset($name)
        {
		   $this->LogEntry(__METHOD__);
           if (is_string($name) &amp;amp;amp;amp;amp;&amp;amp;amp;amp;amp; array_key_exists($name, $this->_data))
            unset($this->_data[$name]);
           else
            throw new Exception("Unsetting non-existant property");
        }

        /* When a class is serialized (eg. put away into cold storage)
         * it is checked for a __sleep method. If it exists it is called
         * to allow the class to prepare a list with names of its most important
         * variables for safe storage.
         *
         * @returns array Critical variables that need to be stored
         */

        public function __sleep()
        {
			$this->LogEntry(__METHOD__);
            return array("_meaningOfLife","_className","_constructorName",
                         "_fileName","_data");
        }

        /* On deserialization the class needs to re-initialise.
         * This is a good point to re-establish the database connection and
         * any other critical (but not storable) resources.
         */

        public function __wakeup()
        {
			$this->LogEntry(__METHOD__);
        }

        /* When an object is "cloned" an exact copy is created. This is not
         * always desirable (think resource handles that are now shared by two
         * objects). The __clone magic function is called on the COPY and
         * allows it to initialise any variables it sees fit.
         */

        public function __clone()
        {
			$this->LogEntry(__METHOD__);
        	// Clones know they are copies because only the original
            // object has an _instanceCount value of 0.
            $this->_instanceCount++;
        }

        /* Used by var_export which allows the creation of a PHP evaluable
         * string that would re-create this object.
         *
         * See also: http://www.thoughtlabs.com/2008/02/02/phps-mystical-__set_state-method/
         */

        public static function __set_state($an_array)
        {
        	echo "static::__set_state called" . PHP_EOL;			

			// Create a new class, set its parameters and
			// exit. 

			$tmp = new DemoPHP5Class();
			foreach($an_array as $name => $value)
			 $tmp->$name = $value;

			return $tmp;
        }

    }

    /* Enable strict warnings */
    error_reporting(E_ALL | E_STRICT);

    /* Test Code */
    $demo = new DemoPHP5Class();

    /* Example of a class constant */
    echo "Class version: " . DemoPHP5Class::VERSION . PHP_EOL;  

    /* Test #1:  Abstract method in parent class, simply call it*/
	$demo->AbstractTest();

	/* Test #2:  Call the Interface member */
	$demo->InterfaceTest();

	/* Test #3:  Call of a static member */
	DemoPHP5Class::StaticTest(20);

	/* Test #4:  Call a regular get method  */
	$demo->GetClassName();

	/* Test #5:  Call a regular set method with valid param */
	$demo->SetMeaningOfLife(43);

	/* Test #6:  Call a regular set method with INVALID param */
	try {
		$demo->SetMeaningOfLife(42.5);
	}
	catch (Exception $e) {
		echo "Exception Caught OK" . PHP_EOL;
	}

	/* Test #7: Try to print the object , calling __tostring() */
	echo $demo;

	/* Test #8: Invoke the object , bit like magic really */
	/* 			only available from PHP 5.3.0 up	      */
	if (PHP_VERSION_ID > 50300)
	 $demo('abacradaba');

	/* Test #9: Set an non-existant member of the object, causing
	 * a call to __set, which will emulate/store the value
	 */		 

	$demo->non_existing_member = 256;

	/* Test #10: Confirm that the new member has been set */

	if (isset($demo->non_existing_member))
	 echo 'Confirmed existance of \$demo->non_existing_member' . PHP_EOL;
	else
	 echo 'Failed to verify setting of \$demo->non_existing_member' . PHP_EOL;

	/* Test #11: Retrieve the non-existing member, causing a call
	 * to __get, which will attempt to retrieve it from the internal
	 * storage array.
	 */

	if ($demo->non_existing_member == 256)
		echo "Retrieval of \$demo->non_existing_member succesfull" . PHP_EOL;
	else
		echo "Retrieval of \$demo->non_existing_member FAILED" . PHP_EOL;

	/* Test #12: Remove the member, and test if this was succesfull */

	unset($demo->non_existing_member);
	if (!isset($demo->non_existing_member))
	 	echo 'Confirmed removal of \$demo->non_existing_member' . PHP_EOL;
	else
	 	echo 'Failed to remove \$demo->non_existing_member' . PHP_EOL;

	/* Test #13: Serialization , put the object to sleep and turn it
	 * into a form that we can store away savely.
	 */

	$serialized_data = serialize( $demo );
	$demo2 = unserialize($serialized_data);  

	/* Test #14: Cloning. After cloning the object the clone should
	 * have a higher instance value than the original object because
	 * of the additional changes made by __clone
	 */

	$demo3 = clone $demo;
	if ($demo3->GetInstanceCount() > $demo->GetInstanceCount())
	 	echo "Succesfull cloning; instance count has been increased. " . PHP_EOL;
	else
	 	echo "Failed to clone; instance count is the same. " . PHP_EOL;

	/* Test 15: Var_Export must produce valid PHP code that can be
	 * run through 'eval'. It has trouble with objects , so it needs
	 * a little help from the __set_state magic function
	 */

	eval('$demo4 = ' . var_export($demo, true) . ';');

	/* Remember, we modified the meaning of life to 43 in $demo */
	if ($demo4->GetMeaningOfLife()==$demo->GetMeaningOfLife())
	 echo "Succesfull re-creation of the \$demo class" . PHP_EOL;
	else
	 echo "Failed to recreate. The meaning of life was lost. " . PHP_EOL; 

	/* EOF */

?>

The Ultimate PHP5 OOP Class is a post from: Martijn's PHP Coding Blog

XML Summer School by psd @ flickr

Below are some of the notes I made while preparing for the Zend PHP5 exam. They are a quick memory jog of how SimpleXML works and its limitations.

The SimpleXML extension provides easier access to XML files. It is simpler to use but also much more limited than the DOM XML extension. If your document makes use of XML namespaces (ns:foo) then it is better NOT to use SimpleXML as it will become anything but simple.

SimpleXML only supports XML 1.0. If fed an XML 1.1 document it will show “Unsupported version ’1.1′” warnings, but will continue and attempt to read the file.

Removing elements is not really supported and the opportunities for modification are limited. SimpleXML is best used for straightforward reading and using of XML files.

1. Documentation

http://php.net/manual/en/book.simplexml.php

2. Demo XML file

This example XML catalog.xml file looks really familiar.

<?xml version="1.0"?>
<catalog>
    <book id="bk101">
        <author>Gambardella, Matthew</author>
        <title>XML Developer's Guide</title>
        <genre>Computer</genre>
        <price>44.95</price>
        <publish_date>2000-10-01</publish_date>
        <description>An in-depth look at creating applications with XML.</description>
    </book>
    <book id="bk102">
        <author>Ralls, Kim</author>
        <title>Midnight Rain</title>
        <genre>Fantasy</genre>
        <price>5.95</price>
        <publish_date>2000-12-16</publish_date>
        <description>A former architect battles corporate zombies,
         an evil sorceress, and her own childhood to become queen
         of the world.</description>
    </book>
</catalog>

3. Loading an XML file

There are four approaches to loading an XML file using SimpleXML.

3.1 Loading from a string

<?php
    $xml = file_get_contents("catalog.xml");
    $simple_xml_obj = simplexml_load_string($xml);
    if ($simple_xml_obj !== FALSE) {
        var_dump($simple_xml_obj);
    } else {
        echo "Invalid XML file" . PHP_EOL;
    }
?>

3.2 Loading the XML file directly

<?php
    $simple_xml_obj = simplexml_load_file("catalog.xml");
    if ($simple_xml_obj !== FALSE) {
        var_dump($simple_xml_obj);
    } else {
        echo "Invalid XML file" . PHP_EOL;
    }
?>

3.3 Loading from a string using the SimpleXML constructor

If creating an SimpleXML instance from a string we need to be wary of possible exceptions.

<?php
    $xml = file_get_contents("catalog.xml");
    try {
        $simple_xml_obj = new SimpleXMLElement($xml);
        var_dump($simple_xml_obj);
    }
    catch (Exception $e)  {
        echo "Oops: " . $e->getMessage() . PHP_EOL;
    }
?>

3.4 Loading the XML file directly with the class constructor

By setting the third parameter of the constructor (data_is_url) to true we can ask the class to directly load the XML file.

<?php
    $filename = "catalog.xml";
    try
    {
        $simple_xml_obj = new SimpleXMLElement($filename,NULL,true);
        var_dump($simple_xml_obj);
    }
    catch (Exception $e)
    {
        echo "Oops: " . $e->getMessage() . PHP_EOL;
    }
?>

4. Usage examples

The benefit of SimpleXML over other solutions is that it makes accessing elements of the XML file EASY.

4.1 Stepping through the XML file by name

If you are familiar with the XML file and know the names of the elements you can refer directly to them in your code:

<?php
    $filename = "catalog.xml";
    $simple_xml_obj = new SimpleXMLElement($filename,NULL,true);

    foreach($simple_xml_obj->book as $book)
    {
        // Access attributes through a named array
        echo "Book ID: {$book['id']}" . PHP_EOL;

        // Access sub elements using ->
        echo "Book Author: {$book->author}" . PHP_EOL;
        echo "Book Title: {$book->title}" . PHP_EOL;
        echo "Book Genre: {$book->genre}" . PHP_EOL;
        echo "Book Price: {$book->price}" . PHP_EOL;
        echo "Book Published date: {$book->publish_date}" . PHP_EOL;
        echo "Book Description: {$book->description}" . PHP_EOL;
    }
?>

4.2 Discovering the contents of the XML file

The children() method will returns an itterator of SimpleXMLElement elements containing each of the children. If used from the top node, this will allow you to step through the entire XML file. The attributes() method returns an iterator of key, value pairs containing all the attributes of the current XML tag.

<?php

    /* Discover the contents of an XML file recursivly
     *
     * @param    $input     A SimpleXMLElement to discover
     * @param    $depth     (optional) recursive dept, used for spacing
     * @returns
     */

    function DiscoverXML($xml,$depth = 0)
    {
        $spacing = str_repeat(' ',$depth);

        // Show the name of the current node
        echo $spacing . '<' . $xml->getName() . '>' ;

        // Show the value of the current node, do this by casting the
        // current element to a string.
        echo trim((string) $xml);

        // Show the attributes of the current node
        foreach($xml->attributes() as $name => $value)
            echo $spacing . " Atrribute {$name} = {$value}" . PHP_EOL;

        // Go deeper and discover any child nodes
        foreach($xml->children() as $child)
         DiscoverXML($child,$depth+1);

        // Close the current tag
        echo $spacing . '</' . $xml->getName() . '>' . PHP_EOL;
    }

    $filename = "catalog.xml";
    $simple_xml_obj = new SimpleXMLElement($filename,NULL,true);

    DiscoverXML($simple_xml_obj);
?>

4.3 Changing elements

Existing elements can be simply modified by assigning them a new value.

<?php

    $filename = "catalog.xml";
    $simple_xml_obj = new SimpleXMLElement($filename,NULL,true);

    $simple_xml_obj->book[0]->title = "Hello World";
    $simple_xml_obj->book[1]->title = "Vampire Mania";

    var_dump($simple_xml_obj);
?>

4.4 Adding a new element

<?php

    $filename = "catalog.xml";
    $simple_xml_obj = new SimpleXMLElement($filename,NULL,true);

    $book = $simple_xml_obj->addChild('book');

    $book->addAttribute('id','1234');
    $book->addChild('author','Vars Unlimited');
    $book->addChild('title','PHP through the ages');
    $book->addChild('genre','historical');
    $book->addChild('price','10.95');
    $book->addChild('publish date','2010-1-1');
    $book->addChild('description','One of the finest examples of rewriting history');

    var_dump($simple_xml_obj);
?>

4.5 Using XPath

XPath, the XML Path Language, is a query language for selecting nodes from an XML document. In the code below we locate all the prices. Note the ‘element/sub element/sub sub element’ notation.

<?php

    $filename = "catalog.xml";
    $simple_xml_obj = new SimpleXMLElement($filename,NULL,true);

    $search_result = $simple_xml_obj->xpath('/catalog/book/price');

    foreach($search_result as $price)
        echo $price . PHP_EOL;

?>

XPath is a query language — it allows you to select nodes based on criteria. For example, to only pick the books more expensive than $6 :

<?php

    $filename = "catalog.xml";
    $simple_xml_obj = new SimpleXMLElement($filename,NULL,true);

    $search_result = $simple_xml_obj->xpath('/catalog/book[price>6]/price');

    foreach($search_result as $price)
        echo $price . PHP_EOL;

?>

4.6 Exporting XML

To export the in memory contents of a SimpleXMLElement we can use the ‘asXML’ method:

<?php
    $filename = "catalog.xml";
    $simple_xml_obj = new SimpleXMLElement($filename,NULL,true);
    echo $simple_xml_obj->asXML();
?>

It is also possible to write the XML to disk by passing a file name:

<?php

    $filename = "catalog.xml";
    $simple_xml_obj = new SimpleXMLElement($filename,NULL,true);

    if (!$simple_xml_obj->asXML('/tmp/out.xml'))
        echo "Unable to save the XML file!" . PHP_EOL;

?>

PHP5 : SimpleXML Study Notes is a post from: Martijn's PHP Coding Blog