Examples
We define 3 classes, each implementing a different storage method:
Example #1 storage_classes.inc
<?php
class FileStorage {
var $data;
function FileStorage($data)
{
$this->data = $data;
}
function write($name)
{
$fp = fopen(name, "w");
fwrite($fp, $this->data);
fclose($data);
}
}
class WDDXStorage {
var $data;
var $version = "1.0";
var $_id; // "private" variable
function WDDXStorage($data)
{
$this->data = $data;
$this->_id = $this->_genID();
}
function store()
{
if ($this->_id) {
$pid = wddx_packet_start($this->_id);
wddx_add_vars($pid, "this->data");
$packet = wddx_packet_end($pid);
} else {
$packet = wddx_serialize_value($this->data);
}
$dbh = dba_open("varstore", "w", "gdbm");
dba_insert(md5(uniqid("", true)), $packet, $dbh);
dba_close($dbh);
}
// a private method
function _genID()
{
return md5(uniqid(rand(), true));
}
}
class DBStorage {
var $data;
var $dbtype = "mysql";
function DBStorage($data)
{
$this->data = $data;
}
function save()
{
$dbh = mysql_connect();
mysql_select_db("storage", $dbh);
$serdata = serialize($this->data);
mysql_query("insert into vars ('$serdata',now())", $dbh);
mysql_close($dbh);
}
}
?>
We then instantiate a couple of objects from the defined classes, and
perform some aggregations and deaggregations, printing some object information
along the way:
Example #2 test_aggregation.php
<?php
include "storageclasses.inc";
// some utilty functions
function p_arr($arr)
{
foreach ($arr as $k => $v)
$out[] = "\t$k => $v";
return implode("\n", $out);
}
function object_info($obj)
{
$out[] = "Class: " . get_class($obj);
foreach (get_object_vars($obj) as $var=>$val) {
if (is_array($val)) {
$out[] = "property: $var (array)\n" . p_arr($val);
} else {
$out[] = "property: $var = $val";
}
}
foreach (get_class_methods($obj) as $method) {
$out[] = "method: $method";
}
return implode("\n", $out);
}
$data = array(M_PI, "kludge != cruft");
// we create some basic objects
$fs = new FileStorage($data);
$ws = new WDDXStorage($data);
// print information on the objects
echo "\$fs object\n";
echo object_info($fs) . "\n";
echo "\n\$ws object\n";
echo object_info($ws) . "\n";
// do some aggregation
echo "\nLet's aggregate \$fs to the WDDXStorage class\n";
aggregate($fs, "WDDXStorage");
echo "\$fs object\n";
echo object_info($fs) . "\n";
echo "\nNow let us aggregate it to the DBStorage class\n";
aggregate($fs, "DBStorage");
echo "\$fs object\n";
echo object_info($fs) . "\n";
echo "\nAnd finally deaggregate WDDXStorage\n";
deaggregate($fs, "WDDXStorage");
echo "\$fs object\n";
echo object_info($fs) . "\n";
?>
We will now consider the output to understand some of the side-effects
and limitation of object aggregation in PHP.
First, the newly created $fs and $ws
objects give the expected output (according to their respective class
declaration). Note that for the purposes of object aggregation,
private elements of a class/object begin with an underscore
character ("_"), even though there is not real distinction between
public and private class/object elements in PHP.
We then aggregate $fs with the
WDDXStorage class, and print out the object
information. We can see now that even though nominally the
$fs object is still of
FileStorage, it now has the property
$version, and the method store(),
both defined in WDDXStorage. One important thing
to note is that it has not aggregated the private elements defined in
the class, which are present in the $ws object. Also
absent is the constructor from WDDXStorage, which
will not be logical to aggegate.
The process of aggregation is cumulative, so when we aggregate
$fs with the class DBStorage,
generating an object that can use the storage methods of all the
defined classes.
Finally, the same way we aggregated properties and methods dynamically,
we can also deaggregate them from the object. So, if we deaggregate the
class WDDXStorage from $fs, we
will obtain:
One point that we have not mentioned above, is that the process of
aggregation will not override existing properties or methods in the
objects. For example, the class FileStorage defines a
$data property, and the class
WDDXStorage also defines a similar property
which will not override the one in the object acquired during
instantiation from the class FileStorage.
Load balance : Server 02
