In stavanger

taking a look at the local dance scene

a view to Stavanger town

checking out a oil drill

on the way back to Oslo, checking out the scenery

my sisters boyfriend telling the elePHPant to take it easy

taking in the view

the little know migration path for elePHPants

Make sure to check out pictures of elePHPant around the world.

That said: nrk.no is a national broadcast company that requires you to install Silverlight in order to listen in to the old shows…. so much for my tax-money working in my advantage… They should seriously re-think their strategy, maybe talk to nrkbeta.no, which is their own company, experimenting with torrents ( they put some of their shows online for free there ). Make them come up with a player, or just a good ‘ol stream that can be played from wherever.

Anyway, not going to rant tonight: congrats to the national rap show, and let’s hope they continue for another 15 years!

The arran tasting

arran

• 10yo
  This is the standard Arran bottle that you’d get in Norway, a typical summer whisky for my part: some honey, apples, citrus and a fair bit of malt and the oak cask it spent a decade on. This is a bottle that I try to have at home: summery and affordable, great buy!
• 7yo
  This is a special bottling for Jon Bertelsen ( mostly know for his Cognac bottlings ) that has aged 7 years: this was the “worst” of the bottlings we had: it shines through that it’s just 7 years, but you can absolutely see where it’s going compared to the 10yo. Some fruit and vanilla when nosing it, but it was a bit raw on the taste.
• Single cask #1038
  Bottle 220 of 240 from this bourbon cask. The single casks from Arran are beautiful bottles, we’ve had some arrive in Norway that are just stunning, and this is one of them: smelling of caramell and vanilla, taste: you could really feel the cask here, some liquorish in-between and a splash of water got me some peach. At this time we were sitting 4 people around the table just smiling, and we had still 3 more bottles to taste!
• Single cask #2131
  Bottle 23 of 196. This cask reached legendary status in Norway last year when it came out: a bourbon cask so dark you wouldn’t believe it! This is one of the better bottles that I’ve ever had in my possession, on the nose there’s a explosion of smells: rum, vanilla, cocoa and the taste is smooth, so smooth that the entire group went quiet and all you could hear was the people enjoying the taste: dark vanilla, liquorish, cocoa and the longest finish I think I’ve had in a bottle of whisky! Winner of the night!
• Single cask #24
  Bottle 364 of 669 from a sherry cask. Here the sherry cask came out and the summer associations that I always have with the 10yo came back, just a lot smoother.
• Cask strength
  The last one of the evening: vanilla, spices, liquorish, maybe a bit harsh on the tongue, but a little water and it went down very well.

We ended up discussing the arrans over a Macallan 18yo long into the night. A very special tasting!

Balsam

Me and some friends got together at Balsam in Oslo one night and tasted:

• Glengoyne 10yo
  Not the big taste experience, quite dull actually
• Glengoyne 18yo Billy’s Choice
  This one came from a Amontillado Hogshead, nosing it there was a lot of chocolate and orange, but then it came to the taste: cask, and a lot of it! This was not a very plesant experience, I could taste some chocolate in-between, but in my opinion it was ruined by the cask. Maybe some like it ( actually: at first I could not figure out if it was a whisky or a cognac ), but this was too sweet and colored by the cask

nmwl meeting

Last week me and a friend went to the nmwl meeting where there was a competition: 5 whiskies tasted blind, question: what cask was it stored on? This one was hard, really hard! But interesting, we sat down on teams of 5 and tasted and discussed the following bottles:

• Glen Douglas 2001 Unpeated American Oak #333 45%
• Springbank 1991 16yo Rhum Wood 54,2%
• Strathisla 1987 21yo Port Wood 57,1% (Cadenhead’s)
• Inchmurrin 2002 Unpeated Madeira Puncheon #3 45%
• Croftenga 2003 Heavily Peated Sherry Butt #1 45%

Some very special casks there ( me drinking a lot of islay whisky ) and the taste on a couple of them was….. not interesting, just bad. But it gave us a opportunity to taste some different casks.

Before the tasting I also got to taste a 1991 Bruichladdich ( Berrys own ) that was very good, and a 2001 bottling from Bruichladdich that was specially bottled for the norwegian market ( and marks the start of the new batch after they got acquired.

Dr.Jekylls

At Dr.Jekylls in Oslo I got the chance to taste the brand new Ardbeg Renaissance that is the first 10yo from the new batch: this is one to buy if you ever have been into Ardbeg of Islay whisky! The peat, honey and the loooong aftertaste was absolutely worth it! If you are ever in Oslo and want to taste some good whisky ( even though they are a bit pricy at times ): drop by this pub, they have a excellent sellection and a very good staff!

That’s it, a couple of whiskies tasted this summer, think I’ll blog a bit more often about this ( so that I can remember more on the taste! ) until then: slainte!

ArrayIterator

The ArrayIterator does exactly what it tells you: it’s used to iterate over an array of values, with it you can easily iterate over values like you would any other collection with a normal iterator. It has the ability to seek and rewind on the array in question and get the current key and value.

Let’s start with a simple example that shows the bare bones of what a ArrayIterator looks like:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

<?php
// Array of php sites:
$array = array(  
    "php" => "php.net",
    "pecl" => "pecl.php.net",
    "pear" => "pear.php.net",
    "bugs" => "bugs.php.net"
);
 
// ArrayObject wraps a array and gives you OOP
// access to it for manipulation:
$obj = new ArrayObject( $array );
 
// Add a new site to the ArrayObject:
$obj->offsetSet( "cvs", "cvs.php.net" );
 
// How many items are we iterating over?
echo "Iterating over: " . $obj->count() . " values\n";
 
// The foreach construct will call $obj->getIterator() which returns
// an ArrayIterator to travers itself. That ArrayIterator implements 
// interface Iterator and can therefore be used in foreach.
foreach( $obj as $key => $value ) {
	echo "Key=$key, value=$value\n";
}
?>

As you can see: the ArrayIterator is not really used directly, but implicit with the foreach construct. But you don’t have to use the builtin ArrayObject to use the ArrayIterator, in fact: you can add a array directly to the ArrayIterator and iterate over it, but here’s a example that use a custom class that implement the IteratorAggregate interface. The IteratorAggregate interface has a single function to implement getIterator(), this is the “magic” method called in the foreach construct in the previous example.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

<?php
/**
 * Custom array class
 * It really doesn't do much functionality, all it
 * does is to check that the array elements we
 * are adding doesn't have a key and a value that
 * is the same.
 */
class MyArray implements IteratorAggregate {
	// Collection of items
	private $arr;
 
	/**
	 * Constructor, initialize a empty array   
	 */
 	public function __construct() {
		$this->arr = array();   
	}
 
	/**
	 * Add a new array element to MyArray.
	 * Checks to see if the $key and the $value is
	 * the same before adding it to the internal array.
	 * ( yes: a really bogus example, but this is just for
	 * showing some functionality )
	 */
	public function add( $key, $value ) {
		if( $this->check( $key, $value ) ) {
			$this->arr[$key] = $value;
		}
	}
 
	/**
	 * Private function that checks if $key and $value
	 * are the same.
	 */
	private function check( $key, $value ) {
		if( $key == $value ) {
			return false;
		}
		return true;
	}
 
	/**
	 * The method that a class implementing the
	 * IteratorAggregate interface needs to implement.
	 */
	public function getIterator() {
		return new ArrayIterator( $this->arr );
	}       
}
?>

This class can be used like this:

1
2
3
4
5
6
7
8
9
10
11

$obj = new MyArray();
$obj->add( "php", "php.net" );
// Try to add a element where both key and value
// are the same:
$obj->add( "php", "php" );
 
// Here the getIterator() function will be called on the
// MyArray object
foreach( $obj as $key => $value ) {
	echo "key=$key, value=$value\n";
}

And the output will be ( note that the second element we tried to add isn’t here ):

key=php, value=php.net

So here we’ve looked at how ArrayObject uses the ArrayIterator and how we can create a custom class that can be used to iterate with foreach.

AppendIterator

In the example above we looked at how we can iterate over a single ArrayObject and how the IteratorAggregate interface works, but: if you have multiple elements you might want to iterate over all of these together, this is where the AppendIterator comes to help you.

The following example creates two ArrayObjects and a AppendIterator, there is only a single method here that you need to think about, the append() function that takes a Iterator as argument. The point of the iterator is to collect several collections and iterate over them in one go:

1
2
3
4
5
6
7
8
9
10
11
12

<?php
$sites = array( "wiki.cc", "planet-php.net" );
$othersites = array( "slashdot.org", "maclash.org" );
$one = new ArrayObject( $sites );
$two = new ArrayObject( $othersites );
$iterator = new AppendIterator();
$iterator->append( $one->getIterator() );
$iterator->append( $two->getIterator() );
foreach( $iterator as $site ) {
    echo $site . "\n";
}
?>

This will give you:

wiki.cc
planet-php.net
slashdot.org,
maclash.org

As you can see: with the AppendIterator you can collect up elements from several sources (objects) and display them all in one go, let’s look at a better example: we have a ‘CMS’ where each type extends a Element class ( all elements in our CMS must be of the same type) , there are also element collections that collects up N-elements and provides us with a Iterator to iterate over all the module elements currently loaded.

To display all links and articles in our system we can come up with the following code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

<?php
abstract class Element {
    public $title;
}
class Link extends Element {
    public function __construct( $title ) {
        $this->title = $title;
    }
}
class Article extends Element {
    public function __construct( $title ) {
        $this->title = $title;
    }
}
abstract class ElementCollection implements IteratorAggregate {
    private $elements;
    public function __construct() {
        $this->elements = new ArrayObject();
    }
    public function addElement( Element $module ) {
    	$this->elements->append( $module );
    }
    public function getIterator() {
        return $this->elements->getIterator();
    }
}
class ArticleCollection extends ElementCollection {
    public function __construct() {
        parent::__construct();
        $this->collectArticles();
    }
    private function collectArticles() {
        // Do some fancy DB stuff
        $a = new Article( "Article one" );
        $b = new Article( "Article two" );
        $this->addElement( $a );
        $this->addElement( $b );
    }
}
class LinkCollection extends ElementCollection {
    public function __construct() {
        parent::__construct();
        $this->collectLinks();
    }
    private function collectLinks() {
        // Do some fancy DB stuff
        $a = new Link( "Link one" );
        $b = new Link( "Link two" );
        $this->addElement( $a );
        $this->addElement( $b );
    }
}
/*
 * Now for the magic: we create two collections and append
 * the iterator for each collection to a single AppendIterator.
 * We can now iterate over all elements in one go and display
 * the module title.
 */
$article = new ArticleCollection();
$link = new LinkCollection();
$it = new AppendIterator();
$it->append( $article->getIterator() );
$it->append( $link->getIterator() );
foreach( $it as $module ) {
    echo $module->title . "\n";
}
?>

This will give you:

Article one
Article two
Link one
Link two

and you have successfully collected elements together to iterate over in one foreach loop.

FilterIterator

There are many ways to iterate over a collection of items, but you might not want to display everything at any given time; say hello to the FilterIterator, a abstract class that have one function you will need to implement: accept.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

<?php
/**
 * Our filter, it implements the accept() function,
 * this is where we decide what will be accepted by
 * the foreach further down
 */
class Filter extends FilterIterator {
    /**
     * The filteriterator needs a iterator as param:
     */
	public function __construct( Iterator $it ) {
        parent::__construct( $it );
    }
 
    /**
     *  When we iterate over the array the following
     *  function will be called to see wether we should
     *  accept the current key:
     */ 
    public function accept() {
        if( preg_match( "/^php/", $this->getInnerIterator()->key() ) ) {
			return true;
        }       
        return false;
    }
}
 
$arr = array(  
    "php" => "php.net",
    "php_pecl" => "pecl.php.net",
    "perl" => "perl.org",
    "python" => "python.org"
);
 
$obj = new ArrayObject( $arr ); 
 
$it = new Filter( $obj->getIterator() );
 
foreach( $it as $key => $value ) {
	echo "key=$key, value=$value\n";
}

Running this will give us ( as we would suspect ) the following:

key=php, value=php.net
key=php_pecl, value=pecl.php.net

And we have successfully filtered out anything where the key doesn’t start with php.
A FilterIterator can be very useful when you are iterating over items and want to automaticly check the current item before outputting it ( a “adult filter” can be one example of what you want to implement ).

LimitIterator

Now: you have a large result set, but only want to display a certain part of it, what do you do? Create a counter, increment it and see if we have reached the amount for the current page? No: you create a LimitIterator that will do it for you. The LimitIterator is a class that keeps track of how many items there are in a iterator and display the number you specify in the constructor.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

<?php
// Array with items:
$arr = array(
    "php" => "php.net",
    "perl"  => "perl.org",
    "python" => "python.org"
);
 
// Array object with all our web sites
$obj = new ArrayObject( $arr ); 
/*
 *  The limit iterator takes a iterator as the first
 *  param, then where you want to start, and finally how
 *  many you want to display:
 */
$it = new LimitIterator( $obj->getIterator(), 0, 1  );
foreach( $it as $key => $value )  {
    echo "key=$key, value=$value\n"; 
}   
?>

We tell the LimitIterator to display from item 0, and show 1 item, running this we will see:

key=php, value=php.net

which is correct.

Let’s create three “pages” where we display one item for each page ( not the best of examples, but it will demonstrate the effect of passing a new starting point to the LimitIterator )

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

<?php
// Array with items:
$arr = array(
    "php" => "php.net",
    "perl"  => "perl.org",
    "python" => "python.org"
);
 
// Array object with all our web sites
$obj = new ArrayObject( $arr ); 
 
$page = 0;
$perPage = 1;
 
for( $i = 0; $i < 3; $i++ ) {
    echo "\n----Page #" . $page . "-----------\n";
    $it = new LimitIterator( $obj->getIterator(), $page, $perPage  );
    foreach( $it as $key => $value ) {
        echo "key=$key, value=$value\n";
    }   
    $page++;
}
?>

This will give the following output:

----Page #0-----------
key=php, value=php.net

----Page #1-----------
key=perl, value=perl.org

----Page #2-----------
key=python, value=python.org

That’s it for creating a easy LimitIterator over a Iterator, this can easily be implemented to split up large reports into separate files for every N-elements for example, but only you can set the limits on what to use it for.

NoRewindIterator

The NoRewindIterator Iterator is a iterator that doesn’t call rewind(), so it is a Iterator that can only be used once.

First: let’s look at a normal Iterator:

1
2
3
4
5
6
7
8
9

<?php
$sites = array( "wiki.cc", "planet-php.net" );
$arr = new ArrayObject( $sites );
foreach( $arr as $site ) {
    echo $site . "\n";
}
foreach( $arr as $site ) {
    echo $site . "\n";
}?>

This will output:

wiki.cc
planet-php.net
wiki.cc
planet-php.net

But: if we only want the user of a iterator to be able to iterate over a collection once we can use the NoRewindIterator:

1
2
3
4
5
6
7
8
9
10
11

<?php
$sites = array( "wiki.cc", "planet-php.net" );
$arr = new ArrayObject( $sites );
$it = new NoRewindIterator( $arr->getIterator() );
foreach( $it as $site ) {
    echo $site . "\n";
}
foreach( $it as $site ) {
    echo $site . "\n";
}
?>

this will give you:

wiki.cc
planet-php.net

so you can see that we only get the output once, even though we tried to iterate over the collection two times.

The iterators in SPL is a valuable collection that you should have a look at in your day-to-day programming tasks since it has a set of common ways on how to implement various iterating tasks, this will help you and others that will look at your code since they share the commonality of the SPL iterators.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

<?php
class WebSiteCollection implements Countable {
    private $sites;
 
    public function __construct() {
        $this->sites = array( 
        	"http://eide.org",
        	"http://phpvolcano.com"
        );
    }
    public function count() {
        return count( $this->sites );
    }
}
$sites = new WebSiteCollection();
echo "I have " . $sites->count() . " sites";
?>

Running this you will get:
I have 2 sites
As you can see: we call count() on the object and we get how many sites I have running, but: that is not the good thing with Countable: it also hooks into the native count() functionality so that you can do:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

<?php
class WebSiteCollection implements Countable {
    private $sites;
 
    public function __construct() {
        $this->sites = array( 
        	"http://eide.org",
        	"http://phpvolcano.com"
        );
    }
    public function count() {
        return count( $this->sites );
    }
}
$sites = new WebSiteCollection();
 
echo "I have " . count( $sites ) . " sites";
?>

Which will output the same as the first example.

The above examples are very basics, but the power of Countable also lies in the fact that you can manipulate the count within the count() function before returning it, making it respond to a certain flag like the following example where we can set a TLD that we want the count() function to restrict to.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

<?php
class WebSiteCollection implements Countable {
    private $sites;
    private $tldrestriction;
 
    public function __construct() {
        $this->sites = array( 
        	"http://eide.org",
        	"http://phpvolcano.com"
        );
        $this->tldrestriction = null;
    }
 
    public function restrictToTld( $tld ) {
    	$this->tldrestriction = $tld;
    }
 
    public function count() {
        if( null === $this->tldrestriction ) {
    		return count( $this->sites );
        }
        $count = 0;
        foreach( $this->sites as $site ) {
        	if( preg_match( "/".$this->tldrestriction."$/", $site ) ) {
        		$count++;
        	}
        }
        return $count;
    }
}
$sites = new WebSiteCollection();
 
echo "I have " . count( $sites ) . " sites\n";
$sites->restrictToTld( "org" );
echo "I have " . count( $sites ) . " sites\n";

And the output for this will be:
I have 2 sites
I have 1 sites

This has been a short post, but the Countable interface is really easy to use and there is as said only a single function to implement, and by using it you can ensure that your class correctly will return the current number of elements when you start to filter out elements and such.

The testfest is a great introduction to the internals of php and will teach you a lot when it comes to the behavior of the functionality you touch on, so next year: meet up at your local testfest and participate in getting the code coverage for php even higher ( or just digg into writing tests now! ).

First up: me and Ståle went flyfishing a couple of days, didn’t catch anything, but the scenery was nice:

Driving into the fishing area

me doing some flyfishing

Besseggen

We also walked Besseggen, a very famous hike with some 40k people every year taking it. It is also made famous in the Peer Gynt play by Henrik Ibsen. A beautiful walk in the sun, a bit of climbing where you have to make sure not to drop 400 meters down to the water below, but absolutely worth it!

Starting out at Gjendesheim

We walked a alternate route around the Gjendevatnet

The view from Besseggen

Besseggen with the bessvatnet to the right and a 400m drop to the left from the lowest point of the edge

Almost at the top, looking down to Gjendesheim

Adding objects

So, what can the SplObjectStorage do for you? Let’s see how it behaves when we start to use it.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

<?php
 
/**
 *  Test class that we will store in the
 *  SplObjectStorage object.
 */
class StorageTest {
    private $title;
 
    public function __construct( $title ) {
        $this->title = $title;
    }
 
    public function __toString() {
        return $this->title;
    }
}
 
$storage = new SplObjectStorage();
$obj = new StorageTest( "wiki.cc" );
$storage->attach( $obj );
$obj2 = new StorageTest( "eide.org" );
$storage->attach( $obj2 );
 
foreach( $storage as $o ) {
        echo $o;
        echo "\n";
}
?>

And this will, as you most likely would think, display the following:

wiki.cc
eide.org

The SplObjectStorage class implements Iterator and Countable, so we can use the storage object as any other objects that implement these. Just look at this:

1

echo count($storage );

Will output “2″

Adding the same object

The SplObjectStorage is, as the name suggests, a storage, so what will happen if we add the same object twice?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

<?php
/**
 *  Test class that we will store in the
 *  SplObjectStorage object.
 */
class StorageTest {
    private $title;
 
    public function __construct( $title ) {
        $this->title = $title;
    }
 
    public function __toString() {
        return $this->title;
    }
}
 
$storage = new SplObjectStorage();
$obj = new StorageTest( "www.eide.org" );
$storage->attach( $obj );
$storage->attach( $obj );
 
foreach( $storage as $o ) {
        echo $o;
        echo "\n";
}
?>

We now get:

www.eide.org

as output. So: the SplObjectStorage object can tell if you add the same object more than one time, this way we can keep adding N objects to the storage, and we can be sure that when we iterate over the object we will only get unique objects.

Updating objects

What then, if we update a object, will we get more than one object when we iterate over the storage?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

<?php
 
/**
 *  Test class that we will store in the
 *  SplObjectStorage object.
 */
class StorageTest {
    private $title;
 
    public function __construct( $title ) {
        $this->title = $title;
    }
 
    public function __toString() {
        return $this->title;
    }
 
    public function setTitle( $title ) {
        $this->title = $title;
    }
}
 
$storage = new SplObjectStorage();
$obj = new StorageTest( "wiki.cc" );
$storage->attach( $obj );
$obj->setTitle( "eide.org" );
 
$storage->attach( $obj );
 
foreach( $storage as $o ) {
        echo $o;
        echo "\n";
}
?>

We now get:

eide.org

So: we can see that the storage object keeps track of the fact that we are manipulating the same object, and we can safely manipulate objects when adding them to the storage.

Check for objects added

With a storage like SplObjectStorage it is always interesting to check if a certain item has been added or not, this feature is covered with the contains() function:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

<?php
 
/**
 *  Test class that we will store in the
 *  SplObjectStorage object.
 */
class StorageTest {
    private $title;
 
    public function __construct( $title ) {
        $this->title = $title;
    }
 
    public function __toString() {
        return $this->title;
    }
}
 
$storage = new SplObjectStorage();
$obj = new StorageTest( "wiki.cc" );
$storage->attach( $obj );
$obj2 = new StorageTest( "eide.org" );
 
if( $storage->contains( $obj ) ) {
    echo "storage contains the object\n";
} else {
    echo "storage does NOT contain the object\n";
}
if( $storage->contains( $obj2 ) ) {
    echo "storage contains the object\n";
} else {
    echo "storage does NOT contain the object\n";
}
?>

This will give us the following output:

storage contains the object
storage does NOT contain the object

And you can see that SplObjectStorage correctly detects which of the two objects that has been added to it.

Detaching objects

With adding objects there always comes the time when you want to remove a object: this is covered by the detach() function:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

<?php
 
/**
 *  Test class that we will store in the
 *  SplObjectStorage object.
 */
class StorageTest {
    private $title;
 
    public function __construct( $title ) {
        $this->title = $title;
    }
 
    public function __toString() {
        return $this->title;
    }
}
 
$storage = new SplObjectStorage();
$obj = new StorageTest( "eide.org" );
$storage->attach( $obj );
if( $storage->contains( $obj ) ) {
    echo "storage contains the object\n";
} else {
    echo "storage does NOT contain the object\n";
}
$storage->detach( $obj );
if( $storage->contains( $obj ) ) {
    echo "storage contains the object\n";
} else {
    echo "storage does NOT contain the object\n";
}
?>

This will give us:

storage contains the object
storage does NOT contain the object

Finally

The SplObjectStorage object is a nice addition to the SPL family that will ease the use of object collections without worrying about what objects you already have added to the mix.

This week was actually sort of a “comeback” when it comes to hammer throwing for me: I had a session on tuesday night then went to a competition in Hyen on wednesday afternoon! Of course: I threw 45.5 meters on tuesday and only just over 43 on wednesday, but I was so sore after the tuesday night session that I was not able to throw any further ( note to self: don’t do that again… ). If my hand behaves ( I’ve had RSI for a long time that have prevented me from throwing ) I will try to get to the national championship next year, shouldn’t be too hard.

This leads to another question: am I the only programmer that also enjoys a good hammer throwing competition? Let me know!