php-event-dispatcher-1.1.0/ 0000755 0001750 0001750 00000000000 11315713733 014251 5 ustar zigo zigo php-event-dispatcher-1.1.0/Event_Dispatcher-1.1.0/ 0000755 0001750 0001750 00000000000 11315713624 020132 5 ustar zigo zigo php-event-dispatcher-1.1.0/Event_Dispatcher-1.1.0/examples/ 0000755 0001750 0001750 00000000000 11315713624 021750 5 ustar zigo zigo php-event-dispatcher-1.1.0/Event_Dispatcher-1.1.0/examples/cancel.php 0000755 0001750 0001750 00000002077 11315713674 023724 0 ustar zigo zigo
*/
/**
* load Event_Dispatcher package
*/
require_once 'Event/Dispatcher.php';
/**
* example sender
*/
class sender
{
var $_dispatcher = null;
function sender(&$dispatcher)
{
$this->_dispatcher = &$dispatcher;
}
function foo()
{
$this->_dispatcher->post($this, 'onFoo', 'Some Info...');
}
}
/**
* example observer
*/
function receiver1(&$notification)
{
echo "receiver 1 received notification \n";
// the notification will be cancelled and no other observers
// will be notified
$notification->cancelNotification();
}
/**
* example observer
*/
function receiver2(&$notification)
{
echo "receiver 2 received notification \n";
}
$dispatcher = &Event_Dispatcher::getInstance();
$sender = &new sender($dispatcher);
$dispatcher->addObserver('receiver1', 'onFoo');
$dispatcher->addObserver('receiver2', 'onFoo');
$sender->foo();
?> php-event-dispatcher-1.1.0/Event_Dispatcher-1.1.0/examples/object.php 0000755 0001750 0001750 00000002244 11315713674 023741 0 ustar zigo zigo
*/
/**
* load Event_Dispatcher package
*/
require_once 'Event/Dispatcher.php';
/**
* example sender
*/
class sender
{
var $_dispatcher = null;
function sender(&$dispatcher)
{
$this->_dispatcher = &$dispatcher;
}
function foo()
{
$notification = &$this->_dispatcher->post($this, 'onFoo', 'Some Info...');
echo "notification::foo is {$notification->foo} ";
}
}
/**
* example observer
*/
class receiver
{
var $foo;
function notify(&$notification)
{
echo "received notification ";
echo "receiver::foo is {$this->foo} ";
$notification->foo = 'bar';
}
}
$dispatcher = &Event_Dispatcher::getInstance();
$sender = &new sender($dispatcher);
$receiver = new receiver();
$receiver->foo = 42;
// make sure you are using an ampersand here!
$dispatcher->addObserver(array(&$receiver, 'notify'));
$receiver->foo = 'bar';
echo 'sender->foo() ';
$sender->foo();
?> php-event-dispatcher-1.1.0/Event_Dispatcher-1.1.0/examples/debugging.php 0000644 0001750 0001750 00000002141 11315713674 024417 0 ustar zigo zigo
*/
/**
* load Event_Dispatcher package
*/
require_once 'Event/Dispatcher.php';
/**
* example observers
*/
function receiver1(&$notification)
{
echo "receiver 1 received notification \n";
}
function receiver2(&$notification)
{
echo "receiver 2 received notification \n";
}
$dispatcher = &Event_Dispatcher::getInstance();
$dispatcher->addObserver('receiver1', 'onFoo', 'TestClass');
$dispatcher->addObserver('receiver2', 'onFoo', 'AnotherTestClass');
$dispatcher->addObserver('receiver2', 'onBar');
// Test, whether an observer has been registered
$registered = $dispatcher->observerRegistered('receiver1', 'onFoo');
if ($registered === true) {
echo "Observer successfully registered";
}
$observers = $dispatcher->getObservers('onFoo');
echo '
';
print_r($observers);
echo '
';
// Filter using a class name
$observers = $dispatcher->getObservers('onFoo', 'TestClass');
echo '
';
print_r($observers);
echo '
';
?> php-event-dispatcher-1.1.0/Event_Dispatcher-1.1.0/examples/bubbling.php 0000755 0001750 0001750 00000005001 11315713674 024251 0 ustar zigo zigo
*/
/**
* load Event_Dispatcher package
*/
require_once 'Event/Dispatcher.php';
/**
* example sender class
*/
class sender
{
var $_dispatcher = null;
function sender(&$dispatcher)
{
$this->_dispatcher = &$dispatcher;
}
function foo($bubble = true)
{
$this->_dispatcher->post($this, 'onFoo', 'Some Info...', true, $bubble);
}
}
/**
* example observer
*/
function receiver1(&$notification)
{
echo "receiver 1 received notification \n";
}
/**
* example observer
*/
function receiver2(&$notification)
{
echo "receiver 2 received notification \n";
}
/**
* example observer
*/
function receiver3(&$notification)
{
echo "receiver 3 received notification \n";
}
// get the different dispatchers
$dispatcher1 = &Event_Dispatcher::getInstance();
$dispatcher2 = &Event_Dispatcher::getInstance('child');
$dispatcher3 = &Event_Dispatcher::getInstance('grandchild');
// create senders in two different levels
$sender1 = &new sender($dispatcher1);
$sender2 = &new sender($dispatcher2);
// build three levels
$dispatcher1->addNestedDispatcher($dispatcher2);
$dispatcher2->addNestedDispatcher($dispatcher3);
// add observers in level one and two
$dispatcher1->addObserver('receiver1', 'onFoo');
$dispatcher2->addObserver('receiver2', 'onFoo');
// this will bubble up from 1 to 3
echo 'sender1->foo() ';
$sender1->foo();
// this will not bubble up
echo ' ';
echo 'sender1->foo(), but disable bubbling ';
$sender1->foo(false);
// this will bubble up from 2 to 3
echo ' ';
echo 'sender2->foo() ';
$sender2->foo();
// This observer will receive the two pending notifications on level 3
echo ' ';
echo 'dispatcher3->addObserver() ';
$dispatcher3->addObserver('receiver3', 'onFoo');
// remove one level
$success = $dispatcher1->removeNestedDispatcher($dispatcher2);
if ($success === true) {
echo ' ';
echo 'removed nested dispatcher2 from dispatcher1 ';
}
// this will stay in level 1
echo 'sender1->foo() ';
$sender1->foo();
// this will bubble up from 2-3
echo ' ';
echo 'sender2->foo() ';
$sender2->foo();
?> php-event-dispatcher-1.1.0/Event_Dispatcher-1.1.0/examples/notification-class.php 0000755 0001750 0001750 00000003012 11315713674 026256 0 ustar zigo zigo
*/
/**
* load Event_Dispatcher package
*/
require_once 'Event/Dispatcher.php';
/**
* example sender
*
* @package Event_Dispatcher
* @subpackage Examples
* @author Stephan Schmidt
*/
class sender
{
var $_dispatcher = null;
function sender(&$dispatcher)
{
$this->_dispatcher = &$dispatcher;
}
function foo()
{
$this->_dispatcher->post($this, 'onFoo', 'Some Info...');
}
}
function receiver(&$notification)
{
echo 'received notification: ';
echo get_class($notification);
echo ' ';
}
/**
* custom notification class
*
* @package Event_Dispatcher
* @subpackage Examples
* @author Stephan Schmidt
*/
class MyNotification extends Event_Notification
{
}
$dispatcher = &Event_Dispatcher::getInstance();
$dispatcher->setNotificationClass('MyNotification');
$sender = &new sender($dispatcher);
$dispatcher->addObserver('receiver');
echo 'sender->foo() ';
$sender->foo();
Event_Dispatcher::setNotificationClass('MyNotification');
$dispatcher2 = &Event_Dispatcher::getInstance();
$sender2 = &new sender($dispatcher2);
$dispatcher2->addObserver('receiver');
echo ' sender2->foo() ';
$sender2->foo();
?> php-event-dispatcher-1.1.0/Event_Dispatcher-1.1.0/Event/ 0000755 0001750 0001750 00000000000 11315713624 021213 5 ustar zigo zigo php-event-dispatcher-1.1.0/Event_Dispatcher-1.1.0/Event/Dispatcher.php 0000755 0001750 0001750 00000042017 11315713646 024025 0 ustar zigo zigo |
// | Stephan Schmidt |
// +-----------------------------------------------------------------------+
//
// $Id: Dispatcher.php 284686 2009-07-24 05:22:17Z clockwerx $
require_once 'Event/Notification.php';
/**
* Pseudo 'static property' for Notification object
* @global array $GLOBALS["_Event_Dispatcher"]
*/
$GLOBALS['_Event_Dispatcher'] = array(
'NotificationClass' => 'Event_Notification'
);
/**
* Registers a global observer
*/
define('EVENT_DISPATCHER_GLOBAL', '');
/**
* Dispatch notifications using PHP callbacks
*
* The Event_Dispatcher acts acts as a notification dispatch table.
* It is used to notify other objects of interesting things, if
* they meet certain criteria. This information is encapsulated
* in {@link Event_Notification} objects. Client objects register
* themselves with the Event_Dispatcher as observers of specific
* notifications posted by other objects. When an event occurs,
* an object posts an appropriate notification to the Event_Dispatcher.
* The Event_Dispatcher dispatches a message to each
* registered observer, passing the notification as the sole argument.
*
* The Event_Dispatcher is actually a combination of three design
* patterns: the Singleton, {@link http://c2.com/cgi/wiki?MediatorPattern Mediator},
* and Observer patterns. The idea behind Event_Dispatcher is borrowed from
* {@link http://developer.apple.com/documentation/Cocoa/Conceptual/Notifications/index.html Apple's Cocoa framework}.
*
* @category Event
* @package Event_Dispatcher
* @author Bertrand Mansion
* @author Stephan Schmidt
* @copyright 1997-2005 The PHP Group
* @license http://www.opensource.org/licenses/bsd-license.php BSD License
* @version Release: @package_version@
* @link http://pear.php.net/package/Event_Dispatcher
*/
class Event_Dispatcher
{
/**
* Registered observer callbacks
* @var array
* @access private
*/
var $_ro = array();
/**
* Pending notifications
* @var array
* @access private
*/
var $_pending = array();
/**
* Nested observers
* @var array
* @access private
*/
var $_nestedDispatchers = array();
/**
* Name of the dispatcher
* @var string
* @access private
*/
var $_name = null;
/**
* Class used for notifications
* @var string
* @access private
*/
var $_notificationClass = null;
/**
* PHP4 constructor
*
* Please use {@link getInstance()} instead.
*
* @access private
* @param string Name of the notification dispatcher.
*/
function Event_Dispatcher($name)
{
Event_Dispatcher::__construct($name);
}
/**
* PHP5 constructor
*
* Please use {@link getInstance()} instead.
*
* @access private
* @param string Name of the notification dispatcher.
*/
function __construct($name)
{
$this->_name = $name;
$this->_notificationClass = $GLOBALS['_Event_Dispatcher']['NotificationClass'];
}
/**
* Returns a notification dispatcher singleton
*
* There is usually no need to have more than one notification
* center for an application so this is the recommended way
* to get a Event_Dispatcher object.
*
* @param string Name of the notification dispatcher.
* The default notification dispatcher is named __default.
*
* @return object Event_Dispatcher
*/
function &getInstance($name = '__default')
{
static $dispatchers = array();
if (!isset($dispatchers[$name])) {
$dispatchers[$name] = new Event_Dispatcher($name);
}
return $dispatchers[$name];
}
/**
* Registers an observer callback
*
* This method registers a {@link http://www.php.net/manual/en/language.pseudo-types.php#language.types.callback callback}
* which is called when the notification corresponding to the
* criteria given at registration time is posted.
* The criteria are the notification name and eventually the
* class of the object posted with the notification.
*
* If there are any pending notifications corresponding to the criteria
* given here, the callback will be called straight away.
*
* If the notification name is empty, the observer will receive all the
* posted notifications. Same goes for the class name.
*
* @access public
* @param mixed A PHP callback
* @param string Expected notification name, serves as a filter
* @param string Expected contained object class, serves as a filter
* @return void
*/
function addObserver($callback, $nName = EVENT_DISPATCHER_GLOBAL, $class = null)
{
if (is_array($callback)) {
if (is_object($callback[0])) {
// Note : PHP4 does not allow correct object comparison so
// only the class name is used for registration checks.
$reg = get_class($callback[0]).'::'.$callback[1];
} else {
$reg = $callback[0].'::'.$callback[1];
}
} else {
$reg = $callback;
}
$this->_ro[$nName][$reg] = array(
'callback' => $callback,
'class' => $class
);
// Post eventual pending notifications for this observer
if (isset($this->_pending[$nName])) {
foreach (array_keys($this->_pending[$nName]) as $k) {
$notification =& $this->_pending[$nName][$k];
if (!$notification->isNotificationCancelled()) {
$objClass = get_class($notification->getNotificationObject());
if (empty($class) || strcasecmp($class, $objClass) == 0) {
call_user_func_array($callback, array(&$notification));
$notification->increaseNotificationCount();
}
}
}
}
}
/**
* Creates and posts a notification object
*
* The purpose of the optional associated object is generally to pass
* the object posting the notification to the observers, so that the
* observers can query the posting object for more information about
* the event.
*
* Notifications are by default added to a pending notification list.
* This way, if an observer is not registered by the time they are
* posted, it will still be notified when it is added as an observer.
* This behaviour can be turned off in order to make sure that only
* the registered observers will be notified.
*
* The info array serves as a container for any kind of useful
* information. It is added to the notification object and posted along.
*
* @access public
* @param object Notification associated object
* @param string Notification name
* @param array Optional user information
* @param bool Whether the notification is pending
* @param bool Whether you want the notification to bubble up
* @return object The notification object
*/
function &post(&$object, $nName, $info = array(), $pending = true, $bubble = true)
{
$notification =& new $this->_notificationClass($object, $nName, $info);
return $this->postNotification($notification, $pending, $bubble);
}
/**
* Posts the {@link Event_Notification} object
*
* @access public
* @param object The Notification object
* @param bool Whether to post the notification immediately
* @param bool Whether you want the notification to bubble up
* @see Event_Dispatcher::post()
* @return object The notification object
*/
function &postNotification(&$notification, $pending = true, $bubble = true)
{
$nName = $notification->getNotificationName();
if ($pending === true) {
$this->_pending[$nName][] =& $notification;
}
$objClass = get_class($notification->getNotificationObject());
// Find the registered observers
if (isset($this->_ro[$nName])) {
foreach (array_keys($this->_ro[$nName]) as $k) {
$rObserver =& $this->_ro[$nName][$k];
if ($notification->isNotificationCancelled()) {
return $notification;
}
if (empty($rObserver['class']) ||
strcasecmp($rObserver['class'], $objClass) == 0) {
call_user_func_array($rObserver['callback'], array(&$notification));
$notification->increaseNotificationCount();
}
}
}
// Notify globally registered observers
if (isset($this->_ro[EVENT_DISPATCHER_GLOBAL])) {
foreach (array_keys($this->_ro[EVENT_DISPATCHER_GLOBAL]) as $k) {
$rObserver =& $this->_ro[EVENT_DISPATCHER_GLOBAL][$k];
if ($notification->isNotificationCancelled()) {
return $notification;
}
if (empty($rObserver['class']) ||
strcasecmp($rObserver['class'], $objClass) == 0) {
call_user_func_array($rObserver['callback'], array(&$notification));
$notification->increaseNotificationCount();
}
}
}
if ($bubble === false) {
return $notification;
}
// Notify in nested dispatchers
foreach (array_keys($this->_nestedDispatchers) as $nested) {
$notification =& $this->_nestedDispatchers[$nested]->postNotification($notification, $pending);
}
return $notification;
}
/**
* Removes a registered observer that correspond to the given criteria
*
* @access public
* @param mixed A PHP callback
* @param string Notification name
* @param string Contained object class
* @return bool True if an observer was removed, false otherwise
*/
function removeObserver($callback, $nName = EVENT_DISPATCHER_GLOBAL, $class = null)
{
if (is_array($callback)) {
if (is_object($callback[0])) {
$reg = get_class($callback[0]).'::'.$callback[1];
} else {
$reg = $callback[0].'::'.$callback[1];
}
} else {
$reg = $callback;
}
$removed = false;
if (isset($this->_ro[$nName][$reg])) {
if (!empty($class)) {
if (strcasecmp($this->_ro[$nName][$reg]['class'], $class) == 0) {
unset($this->_ro[$nName][$reg]);
$removed = true;
}
} else {
unset($this->_ro[$nName][$reg]);
$removed = true;
}
}
if (isset($this->_ro[$nName]) && count($this->_ro[$nName]) == 0) {
unset($this->_ro[$nName]);
}
return $removed;
}
/**
* Check, whether the specified observer has been registered with the
* dispatcher
*
* @access public
* @param mixed A PHP callback
* @param string Notification name
* @param string Contained object class
* @return bool True if the observer has been registered, false otherwise
*/
function observerRegistered($callback, $nName = EVENT_DISPATCHER_GLOBAL, $class = null)
{
if (is_array($callback)) {
if (is_object($callback[0])) {
$reg = get_class($callback[0]).'::'.$callback[1];
} else {
$reg = $callback[0].'::'.$callback[1];
}
} else {
$reg = $callback;
}
if (!isset($this->_ro[$nName][$reg])) {
return false;
}
if (empty($class)) {
return true;
}
if (strcasecmp($this->_ro[$nName][$reg]['class'], $class) == 0) {
return true;
}
return false;
}
/**
* Get all observers, that have been registered for a notification
*
* @access public
* @param string Notification name
* @param string Contained object class
* @return array List of all observers
*/
function getObservers($nName = EVENT_DISPATCHER_GLOBAL, $class = null)
{
$observers = array();
if (!isset($this->_ro[$nName])) {
return $observers;
}
foreach ($this->_ro[$nName] as $reg => $observer) {
if ($class == null || $observer['class'] == null || strcasecmp($observer['class'], $class) == 0) {
$observers[] = $reg;
}
}
return $observers;
}
/**
* Get the name of the dispatcher.
*
* The name is the unique identifier of a dispatcher.
*
* @access public
* @return string name of the dispatcher
*/
function getName()
{
return $this->_name;
}
/**
* add a new nested dispatcher
*
* Notifications will be broadcasted to this dispatcher as well, which
* allows you to create event bubbling.
*
* @access public
* @param Event_Dispatcher The nested dispatcher
*/
function addNestedDispatcher(&$dispatcher)
{
$name = $dispatcher->getName();
$this->_nestedDispatchers[$name] =& $dispatcher;
}
/**
* remove a nested dispatcher
*
* @access public
* @param Event_Dispatcher Dispatcher to remove
* @return boolean
*/
function removeNestedDispatcher($dispatcher)
{
if (is_object($dispatcher)) {
$dispatcher = $dispatcher->getName();
}
if (!isset($this->_nestedDispatchers[$dispatcher])) {
return false;
}
unset($this->_nestedDispatchers[$dispatcher]);
return true;
}
/**
* Changes the class used for notifications
*
* You may call this method on an object to change it for a single
* dispatcher or statically, to set the default for all dispatchers
* that will be created.
*
* @access public
* @param string name of the notification class
* @return boolean
*/
function setNotificationClass($class)
{
if (isset($this) && is_a($this, 'Event_Dispatcher')) {
$this->_notificationClass = $class;
return true;
}
$GLOBALS['_Event_Dispatcher']['NotificationClass'] = $class;
return true;
}
}
?> php-event-dispatcher-1.1.0/Event_Dispatcher-1.1.0/Event/Notification.php 0000755 0001750 0001750 00000014323 11315713652 024361 0 ustar zigo zigo |
// | Stephan Schmidt |
// +-----------------------------------------------------------------------+
//
// $Id: Notification.php 284686 2009-07-24 05:22:17Z clockwerx $
/**
* Default state of the notification
*/
define('EVENT_NOTIFICATION_STATE_DEFAULT', 0);
/**
* Notification has been cancelled
*/
define('EVENT_NOTIFICATION_STATE_CANCELLED', 1);
/**
* A Notification object
*
* The Notification object can be easily subclassed and serves as a container
* for the information about the notification. It holds an object which is
* usually a reference to the object that posted the notification,
* a notification name used to identify the notification and some user
* information which can be anything you need.
*
* @category Event
* @package Event_Dispatcher
* @author Bertrand Mansion
* @author Stephan Schmidt
* @copyright 1997-2005 The PHP Group
* @license http://www.opensource.org/licenses/bsd-license.php BSD License
* @version Release: @package_version@
* @link http://pear.php.net/package/Event_Dispatcher
*/
class Event_Notification
{
/**
* name of the notofication
* @var string
* @access private
*/
var $_notificationName;
/**
* object of interesed (the sender of the notification, in most cases)
* @var object
* @access private
*/
var $_notificationObject;
/**
* additional information about the notification
* @var mixed
* @access private
*/
var $_notificationInfo = array();
/**
* state of the notification
*
* This may be:
* - EVENT_NOTIFICATION_STATE_DEFAULT
* - EVENT_NOTIFICATION_STATE_CANCELLED
*
* @var integer
* @access private
*/
var $_notificationState = EVENT_NOTIFICATION_STATE_DEFAULT;
/**
* amount of observers that received this notification
* @var mixed
* @access private
*/
var $_notificationCount = 0;
/**
* Constructor
*
* @access public
* @param object The object of interest for the notification,
* usually is the posting object
* @param string Notification name
* @param array Free information array
*/
function Event_Notification(&$object, $name, $info = array())
{
$this->_notificationObject =& $object;
$this->_notificationName = $name;
$this->_notificationInfo = $info;
}
/**
* Returns the notification name
* @return string Notification name
*/
function getNotificationName()
{
return $this->_notificationName;
}
/**
* Returns the contained object
* @return object Contained object
*/
function &getNotificationObject()
{
return $this->_notificationObject;
}
/**
* Returns the user info array
* @return array user info
*/
function getNotificationInfo()
{
return $this->_notificationInfo;
}
/**
* Increase the internal count
*
* @access public
*/
function increaseNotificationCount()
{
++$this->_notificationCount;
}
/**
* Get the number of posted notifications
*
* @access public
* @return int
*/
function getNotificationCount()
{
return $this->_notificationCount;
}
/**
* Cancel the notification
*
* @access public
* @return void
*/
function cancelNotification()
{
$this->_notificationState = EVENT_NOTIFICATION_STATE_CANCELLED;
}
/**
* Checks whether the notification has been cancelled
*
* @access public
* @return boolean
*/
function isNotificationCancelled()
{
return ($this->_notificationState === EVENT_NOTIFICATION_STATE_CANCELLED);
}
}
?> php-event-dispatcher-1.1.0/Event_Dispatcher-1.1.0/tests/ 0000755 0001750 0001750 00000000000 11315713624 021274 5 ustar zigo zigo php-event-dispatcher-1.1.0/Event_Dispatcher-1.1.0/tests/DispatcherTest.php 0000644 0001750 0001750 00000012046 11315713701 024732 0 ustar zigo zigo
* @package Event_Dispatcher
* @subpackage Tests
*/
require_once 'PHPUnit/Framework/TestCase.php';
require_once 'Event/Dispatcher.php';
class Notified
{
var $notif;
function notifReceived(&$notif)
{
$this->notif =& $notif;
}
function description()
{
$notObj =& $this->notif->getNotificationObject();
$name = $this->notif->getNotificationName();
$info = $this->notif->getNotificationInfo();
$desc = $name.':'.implode(':', $info).':'.$notObj->id;
return $desc;
}
}
class Dummy
{
var $id;
function Dummy($id = 'default')
{
$this->id = $id;
}
}
class Notifier
{
var $id = 'notifier';
function Notifier($id)
{
$this->id = $id;
$ed =& Event_Dispatcher::getInstance();
$ed->post($this, 'NotifierInstanciated', array('info'));
}
}
function notified(&$notif)
{
$obj = $notif->getNotificationObject();
$obj->id = $notif->getNotificationName().':'.implode(':', $notif->getNotificationInfo());
}
class DispatcherTest extends PHPUnit_Framework_TestCase
{
// Get the default dispatch center
function test1()
{
$nf = new Notified();
$dm = new Dummy();
$ed =& Event_Dispatcher::getInstance();
// Generic notification, global observer
$ed->addObserver(array(&$nf, 'notifReceived'));
$not =& $ed->post($dm, 'test', array('A', 'B'));
$this->assertEquals('test:A:B:default', $nf->description(), "Error");
$this->assertEquals(1, $not->getNotificationCount(), "Wrong notification count");
// Object references
$dm->id = 'dummy';
$this->assertEquals('test:A:B:dummy', $nf->description(), "Wrong notification description");
// Named notifications
$ed->addObserver('notified', 'NotifierInstanciated');
$nt = new Notifier('notifier');
$this->assertEquals('NotifierInstanciated:info', $nt->id, "Wrong notification id");
// Pending notifications
$not =& $ed->post($nt, 'PendingNotification');
$ed->addObserver(array(&$nf, 'notifReceived'), 'PendingNotification');
$this->assertEquals('PendingNotification::NotifierInstanciated:info', $nf->description(), "Error");
$this->assertEquals(2, $not->getNotificationCount(), "Error");
// Class filter 1
$ed->addObserver(array(&$nf, 'notifReceived'), 'ClassFilterNotification', 'Dummy');
$not =& $ed->post($nt, 'ClassFilterNotification', array('isGlobal'));
$this->assertEquals('ClassFilterNotification:isGlobal:NotifierInstanciated:info', $nf->description(), "Error");
$this->assertEquals(1, $not->getNotificationCount(), "Error");
// Remove observer
$ed->removeObserver(array(&$nf, 'notifReceived'));
$nt->id = 'reset';
$not =& $ed->post($nt, 'ClassFilterNotification', array('test'));
$this->assertEquals('ClassFilterNotification:isGlobal:reset', $nf->description(), "Error");
$this->assertEquals(0, $not->getNotificationCount(), "Error");
// Class filter 2
$not =& $ed->post($dm, 'ClassFilterNotification');
$this->assertEquals('ClassFilterNotification::dummy', $nf->description(), "Error");
$this->assertEquals(1, $not->getNotificationCount(), "Error");
// Re-add the global observer
$ed->addObserver(array(&$nf, 'notifReceived'));
$not =& $ed->post($dm, 'ClassFilterNotification');
$this->assertEquals('ClassFilterNotification::dummy', $nf->description(), "Error");
$this->assertEquals(2, $not->getNotificationCount(), "Error");
}
// Tests with 2 dispatchers
function test2()
{
$nf = new Notified();
$dm = new Dummy();
$ed2 =& Event_Dispatcher::getInstance('another');
$ed1 =& Event_Dispatcher::getInstance();
$ed2->addObserver(array(&$nf, 'notifReceived'));
$not =& $ed2->post($dm, 'test', array('A', 'B'));
$this->assertEquals('test:A:B:default', $nf->description(), "Error");
$this->assertEquals(1, $not->getNotificationCount(), "Error");
$not =& $ed1->post($dm, 'test', array('A2', 'B2'));
$this->assertEquals(1, $not->getNotificationCount(), "Error");
$not =& $ed1->post($dm, 'test', array('A2', 'B2'));
$this->assertEquals(1, $not->getNotificationCount(), "Error");
$ed2->addObserver(array(&$nf, 'notifReceived'), 'ClassFilterNotification', 'Notifier');
$not =& $ed2->post($dm, 'ClassFilterNotification');
$this->assertEquals('ClassFilterNotification::default', $nf->description(), "Error");
$this->assertEquals(1, $not->getNotificationCount(), "Error");
$ed2->addObserver(array(&$nf, 'notifReceived'), 'ClassFilterNotification', 'Dummy');
$not =& $ed2->post($dm, 'ClassFilterNotification');
$this->assertEquals(2, $not->getNotificationCount(), "Error");
}
}
?>
php-event-dispatcher-1.1.0/Event_Dispatcher-1.1.0/tests/AllTests.php 0000644 0001750 0001750 00000001362 11315713701 023536 0 ustar zigo zigo addTestSuite('DispatcherTest');
return $suite;
}
// }}}
}
if (PHPUnit_MAIN_METHOD == 'Event_Dispatcher_AllTests::main') {
Event_Dispatcher_AllTests::main();
}
?>
php-event-dispatcher-1.1.0/package.xml 0000644 0001750 0001750 00000006777 11315713727 016412 0 ustar zigo zigo
Event_Dispatcherpear.php.netDispatch notifications using PHP callbacksThe Event_Dispatcher acts as a notification dispatch table.
It is used to notify other objects of interesting things. This
information is encapsulated in Event_Notification objects. Client
objects register themselves with the Event_Dispatcher as observers of
specific notifications posted by other objects. When an event occurs,
an object posts an appropriate notification to the Event_Dispatcher.
The Event_Dispatcher dispatches a message to each registered
observer, passing the notification as the sole argument.Bertrand Mansionmansionbmansion@mamasam.comnoStephan Schmidtschstschst@php.netno2009-07-241.1.01.0.0stablestableBSD License
Swapped to package 2.0
Swapped to PHPUnit 3
QA release
4.0.01.4.0b10.9.10.9.1betabeta2005-02-05BSD License
First release
1.1.01.0.0stablestable2009-07-24BSD License
Swapped to package 2.0
Swapped to PHPUnit 3
QA release