Question

I’m trying to design a PHP object (call it Incident_Collection) that will hold a collection of other objects each of which implement an Incident interface.

<?php
class Foo implements Incident {
  protected $incident_date; //DateTime object
  protected $prop1;
  protected $prop2;
  //etc

  public function when(){ //required by Incident interface
    return $this->incident_date;
  }

}
?>

At first I figured I’d just make my Incident_Collection implement IteratorAggregate and store the Incident objects in an array property of the collection:

<?php
class Incident_Collection implements IteratorAggregate {
  protected $collection=array();

  public function getIterator(){
    return new ArrayIterator($this->collection);    
  }

  public function sort(){
     //sort by $incident->when() values in $this->collection
  }

  /*also __get($var), __set($var,$value), add(Incident $object), remove(Incident $object) and other functions*/
}
?>

But because Incident objects have a natural order, I thought perhaps extending one of the SPL Data Structures might be more appropriate/efficient. But which one? I’m not very clear about when to use a particular data structure.

Another wrinkle is that there may be restrictions on an Incident_Collection. For example, if there were a Person object who had an Incident_Collection, perhaps the following restrictions might apply:

• only 1 Birth incident
• if Birth exists, it must be the earliest incident in the collection
• only 1 Death incident
• if Death exists, it must be the last incident in the collection
• HS_Graduation must come after HS_Begin

Would it be better to have a generic Incident_Collection that accepts a set of restrictions from its owner (e.g. Person), or a subclassed Person_Incident_Collection?

Answer 1

Check out

• http://matthewturland.com/2010/05/20/new-spl-features-in-php-5-3/

It gives a good overview of the SPL DataStructures, what they are and when you want to use them. There is also benchmarks.

If this is an object collection, I’d definitely consider using SplObjectStorage instead of the plain Array. If the Incidents should be in LIFO or FIFO order consider queues and stacks. If you need them in a custom order, consider a Priority Queue.

Regarding the restrictions, you could use a State Pattern, e.g. access happens through the general IncidentCollection, but depending on it’s owner property, a subclass is applied to handle changing of state. This requires the collection to have a owner property though. Because the individiual states are subclasses of IncidentCollection anyway, you could just as well use them directly though.