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:
Birth
incidentBirth
exists, it must be the earliest incident in the collectionDeath
incidentDeath
exists, it must be the last incident in the collectionHS_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
?
Check out
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.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With