PHP: Object Aggregation/Composition Functions - Manual

downloads | documentation | faq | getting help | mailing lists | reporting bugs | php.net sites | links | conferences | my php.net

search for in the

aggregate_info nsapi_virtual

Last updated: Sat, 27 Jan 2007

view this page in

# CII. Object Aggregation/Composition Functions

Внимание
Это расширение является ЭКСПЕРИМЕНТАЛЬНЫМ. Поведение этого расширения, включая имена его функций и относящуюся к нему документацию, может измениться в последующих версиях PHP без уведомления. Используйте это расширение на свой страх и риск.

# Введение

In Object Oriented Programming, it is common to see the composition of simple classes (and/or instances) into a more complex one. This is a flexible strategy for building complicated objects and object hierarchies and can function as a dynamic alternative to multiple inheritance. There are two ways to perform class (and/or object) composition depending on the relationship between the composed elements: Association and Aggregation.

An Association is a composition of independently constructed and externally visible parts. When we associate classes or objects, each one keeps a reference to the ones it is associated with. When we associate classes statically, one class will contain a reference to an instance of the other class. For example:

Пример 1. Class association

`<?php
class DateTime {
function DateTime()
{
// empty constructor
}
function now()
{
return date("Y-m-d H:i:s");
}
}
class Report {
var $_dt;
// more properties ...
function Report()
{
$this->_dt = new DateTime();
// initialization code ...
}
function generateReport()
{
$dateTime = $this->_dt->now();
// more code ...
}
// more methods ...
}
$rep = new Report();
?>`

We can also associate instances at runtime by passing a reference in a constructor (or any other method), which allow us to dynamically change the association relationship between objects. We will modify the example above to illustrate this point:

Пример 2. Object association

`<?php
class DateTime {
// same as previous example
}
class DateTimePlus {
var $_format;
function DateTimePlus($format="Y-m-d H:i:s")
{
$this->_format = $format;
}
function now()
{
return date($this->_format);
}
}
class Report {
var $_dt; // we'll keep the reference to DateTime here
// more properties ...
function Report()
{
// do some initialization
}
function setDateTime(&$dt)
{
$this->_dt =& $dt;
}
function generateReport()
{
$dateTime = $this->_dt->now();
// more code ...
}
// more methods ...
}
$rep = new Report();
$dt = new DateTime();
$dtp = new DateTimePlus("l, F j, Y (h:i:s a, T)");
// generate report with simple date for web display
$rep->setDateTime(&$dt);
echo $rep->generateReport();
// later on in the code ...
// generate report with fancy date
$rep->setDateTime(&$dtp);
$output = $rep->generateReport();
// save $output in database
// ... etc ...
?>`

Aggregation, on the other hand, implies encapsulation (hidding) of the parts of the composition. We can aggregate classes by using a (static) inner class (PHP does not yet support inner classes), in this case the aggregated class definition is not accessible, except through the class that contains it. The aggregation of instances (object aggregation) involves the dynamic creation of subobjects inside an object, in the process, expanding the properties and methods of that object.

Object aggregation is a natural way of representing a whole-part relationship, (for example, molecules are aggregates of atoms), or can be used to obtain an effect equivalent to multiple inheritance, without having to permanently bind a subclass to two or more parent classes and their interfaces. In fact object aggregation can be more flexible, in which we can select what methods or properties to "inherit" in the aggregated object.

# Примеры

We define 3 classes, each implementing a different storage method:

Пример 3. 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:

Пример 4. 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.

    $fs object
    Class: filestorage
    property: data (array)
        0 => 3.1415926535898
        1 => kludge != cruft
    method: filestorage
    method: write

    $ws object
    Class: wddxstorage
    property: data (array)
        0 => 3.1415926535898
        1 => kludge != cruft
    property: version = 1.0
    property: _id = ID::9bb2b640764d4370eb04808af8b076a5
    method: wddxstorage
    method: store
    method: _genid

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.

    Let's aggregate $fs to the WDDXStorage class
    $fs object
    Class: filestorage
    property: data (array)
        0 => 3.1415926535898
        1 => kludge != cruft
    property: version = 1.0
    method: filestorage
    method: write
    method: store

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.

    Now let us aggregate it to the DBStorage class
    $fs object
    Class: filestorage
    property: data (array)
        0 => 3.1415926535898
        1 => kludge != cruft
    property: version = 1.0
    property: dbtype = mysql
    method: filestorage
    method: write
    method: store
    method: save

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:

    And deaggregate the WDDXStorage methods and properties
    $fs object
    Class: filestorage
    property: data (array)
        0 => 3.1415926535898
        1 => kludge != cruft
    property: dbtype = mysql
    method: filestorage
    method: write
    method: save

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.

add a note User Contributed Notes
Object Aggregation/Composition Functions
kencomer at NOSPAM dot kencomer dot com
20-Sep-2005 09:04
`For PHP5 applications, the all of the "aggregate" function family is now in runkit.
http://php.net/manual/en/ref.runkit.php`
Jeb.
17-Jan-2003 02:18
`It is worth noting that class association does not work, even in PHP 4.3.0 - this ability is experimental. I'm assuming it was added in for the sake of forwards-compatibilty. Use object association instead for now.
Until it is implemented, you will receieve a parse error when attempting to use it.
Related bug report: http://bugs.php.net/bug.php?id=20531
Just to prevent people posting about "why it doesn't work??", etc etc etc.`
Greg Beaver firstname at chiaraquartet dot net
04-Jan-2003 03:54
`If you need to serialize an object for sessions or other purposes, and want to save aggregation state, extend it from a base class such as this one, and use $this->agg/$this->unagg instead of aggregate/deaggregate
<?php
class base
{
var $_aggregates = array();
function agg($agg)
{
aggregate($this,$agg);
$this->_aggregates[$agg] = 1;
}
function unagg($agg = false)
{
if ($agg)
{
deaggregate($this,$agg);
unset($this->_aggregates[$agg]);
} else
{
deaggregate($this);
$this->_aggregates = array();
}
}
}
?>`
add a note
aggregate_info nsapi_virtual

Last updated: Sat, 27 Jan 2007
show source | credits | stats | sitemap | contact | advertising | mirror sites
Copyright © 2001-2007 The PHP Group
All rights reserved.
This mirror generously provided by: Yahoo! Inc.
Last updated: Sat Mar 10 11:33:19 2007 PST