Spade
Mini Shell
PK[���e
interface.phpnu�[���<?php
/**
* @package Joomla.Platform
* @subpackage Observer
*
* @copyright Copyright (C) 2005 - 2020 Open Source Matters, Inc. All
rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
defined('JPATH_PLATFORM') or die;
/**
* Observer pattern interface for Joomla
*
* A class that wants to observe another class must:
*
* 1) Add: implements JObserverInterface
* to its class
*
* 2) Implement a constructor, that can look like this:
* public function __construct(JObservableInterface $observableObject)
* {
* $observableObject->attachObserver($this);
* $this->observableObject = $observableObject;
* }
*
* 3) and must implement the instantiator function createObserver() below,
e.g. as follows:
* public static function createObserver(JObservableInterface
$observableObject, $params = array())
* {
* $observer = new self($observableObject);
* $observer->... = $params['...']; ...
* return $observer;
* }
*
* 4) Then add functions corresponding to the events to be observed,
* E.g. to respond to event:
$this->_observers->update('onBeforeLoad', array($keys,
$reset));
* following function is needed in the observer:
* public function onBeforeLoad($keys, $reset) { ... }
*
* 5) Finally, the binding is made outside the observable and observer
classes, using:
* JObserverMapper::addObserverClassToClass('ObserverClassname',
'ObservableClassname', array('paramName' =>
'paramValue'));
* where the last array will be provided to the observer instanciator
function createObserver.
*
* @since 3.1.2
*/
interface JObserverInterface
{
/**
* Creates the associated observer instance and attaches it to the
$observableObject
*
* @param JObservableInterface $observableObject The observable
subject object
* @param array $params Params for this
observer
*
* @return JObserverInterface
*
* @since 3.1.2
*/
public static function createObserver(JObservableInterface
$observableObject, $params = array());
}
PK[��q͏ �
mapper.phpnu�[���<?php
/**
* @package Joomla.Platform
* @subpackage Observer
*
* @copyright Copyright (C) 2005 - 2020 Open Source Matters, Inc. All
rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
defined('JPATH_PLATFORM') or die;
/**
* Observer mapping pattern implementation for Joomla
*
* @since 3.1.2
*/
class JObserverMapper
{
/**
* Array: array( JObservableInterface_classname => array(
JObserverInterface_classname => array( paramname => param, .... ) ) )
*
* @var array
* @since 3.1.2
*/
protected static $observations = array();
/**
* Adds a mapping to observe $observerClass subjects with $observableClass
observer/listener, attaching it on creation with $params
* on $observableClass instance creations
*
* @param string $observerClass The name of the observer
class (implementing JObserverInterface)
* @param string $observableClass The name of the observable
class (implementing JObservableInterface)
* @param array|boolean $params The params to give to the
JObserverInterface::createObserver() function, or false to remove mapping
*
* @return void
*
* @since 3.1.2
*/
public static function addObserverClassToClass($observerClass,
$observableClass, $params = array())
{
if ($params !== false)
{
static::$observations[$observableClass][$observerClass] = $params;
}
else
{
unset(static::$observations[$observableClass][$observerClass]);
}
}
/**
* Attaches all applicable observers to an $observableObject
*
* @param JObservableInterface $observableObject The observable
subject object
*
* @return void
*
* @since 3.1.2
*/
public static function attachAllObservers(JObservableInterface
$observableObject)
{
$observableClass = get_class($observableObject);
while ($observableClass != false)
{
// Attach applicable Observers for the class to the Observable subject:
if (isset(static::$observations[$observableClass]))
{
foreach (static::$observations[$observableClass] as $observerClass
=> $params)
{
// Attach an Observer to the Observable subject:
/**
* @var JObserverInterface $observerClass
*/
$observerClass::createObserver($observableObject, $params);
}
}
// Get parent class name (or false if none), and redo the above on it:
$observableClass = get_parent_class($observableClass);
}
}
}
PK[Z����updater/interface.phpnu�[���<?php
/**
* @package Joomla.Platform
* @subpackage Observer
*
* @copyright Copyright (C) 2005 - 2020 Open Source Matters, Inc. All
rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
defined('JPATH_PLATFORM') or die;
/**
* Observer updater pattern implementation for Joomla
*
* @since 3.1.2
*/
interface JObserverUpdaterInterface
{
/**
* Constructor
*
* @param JObservableInterface $observable The observable subject
object
*
* @since 3.1.2
*/
public function __construct(JObservableInterface $observable);
/**
* Adds an observer to the JObservableInterface instance updated by this
* This method can be called from JObservableInterface::attachObserver
*
* @param JObserverInterface $observer The observer object
*
* @return void
*
* @since 3.1.2
*/
public function attachObserver(JObserverInterface $observer);
/**
* Call all observers for $event with $params
*
* @param string $event Event name (function name in observer)
* @param array $params Params of event (params in observer function)
*
* @return void
*
* @since 3.1.2
*/
public function update($event, $params);
/**
* Enable/Disable calling of observers (this is useful when calling
parent:: function
*
* @param boolean $enabled Enable (true) or Disable (false) the
observer events
*
* @return boolean Returns old state
*
* @since 3.1.2
*/
public function doCallObservers($enabled);
}
PK[��>��� updater.phpnu�[���<?php
/**
* @package Joomla.Platform
* @subpackage Observer
*
* @copyright Copyright (C) 2005 - 2020 Open Source Matters, Inc. All
rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
defined('JPATH_PLATFORM') or die;
/**
* Observer updater pattern implementation for Joomla
*
* @since 3.1.2
*/
class JObserverUpdater implements JObserverUpdaterInterface
{
/**
* Holds the key aliases for observers.
*
* @var array
* @since 3.9.0
*/
protected $aliases = array();
/**
* Generic JObserverInterface observers for this JObservableInterface
*
* @var JObserverInterface
* @since 3.1.2
*/
protected $observers = array();
/**
* Process observers (useful when a class extends significantly an
observed method, and calls observers itself
*
* @var boolean
* @since 3.1.2
*/
protected $doCallObservers = true;
/**
* Constructor
*
* @param JObservableInterface $observable The observable subject
object
*
* @since 3.1.2
*/
public function __construct(JObservableInterface $observable)
{
// Not yet needed, but possible: $this->observable = $observable;
}
/**
* Adds an observer to the JObservableInterface instance updated by this
* This method can be called from JObservableInterface::attachObserver
*
* @param JObserverInterface $observer The observer object
*
* @return void
*
* @since 3.1.2
*/
public function attachObserver(JObserverInterface $observer)
{
$class = get_class($observer);
// Also register the alias if exists
foreach (JLoader::getDeprecatedAliases() as $alias)
{
$realClass = trim($alias['new'], '\\');
// Check if we have an alias for the observer class
if ($realClass === $class)
{
$aliasClass = trim($alias['old'], '\\');
// Add an alias to known aliases
$this->aliases[$aliasClass] = $class;
}
}
// Register the real class
$this->observers[$class] = $observer;
}
/**
* Removes an observer from the JObservableInterface instance updated by
this
* This method can be called from JObservableInterface::attachObserver
*
* @param String $observer The observer class name
*
* @return void
*
* @since 3.6.0
*/
public function detachObserver($observer)
{
$observer = trim($observer, '\\');
if (isset($this->aliases[$observer]))
{
$observer = $this->aliases[$observer];
}
if (isset($this->observers[$observer]))
{
unset($this->observers[$observer]);
}
}
/**
* Gets the instance of the observer of class $observerClass
*
* @param string $observerClass The class name of the observer
*
* @return JTableObserver|null The observer object of this class if any
*
* @since 3.1.2
*/
public function getObserverOfClass($observerClass)
{
$observerClass = trim($observerClass, '\\');
if (isset($this->aliases[$observerClass]))
{
$observerClass = $this->aliases[$observerClass];
}
if (isset($this->observers[$observerClass]))
{
return $this->observers[$observerClass];
}
return null;
}
/**
* Call all observers for $event with $params
*
* @param string $event Name of the event
* @param array $params Params of the event
*
* @return void
*
* @since 3.1.2
*/
public function update($event, $params)
{
if ($this->doCallObservers)
{
foreach ($this->observers as $observer)
{
$eventListener = array($observer, $event);
if (is_callable($eventListener))
{
call_user_func_array($eventListener, $params);
}
}
}
}
/**
* Enable/Disable calling of observers (this is useful when calling
parent:: function
*
* @param boolean $enabled Enable (true) or Disable (false) the
observer events
*
* @return boolean Returns old state
*
* @since 3.1.2
*/
public function doCallObservers($enabled)
{
$oldState = $this->doCallObservers;
$this->doCallObservers = $enabled;
return $oldState;
}
}
PK[�HGwrapper/mapper.phpnu�[���<?php
/**
* @package Joomla.Platform
* @subpackage Observer
*
* @copyright Copyright (C) 2005 - 2020 Open Source Matters, Inc. All
rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
defined('JPATH_PLATFORM') or die;
/**
* Wrapper class for JObserverMapper
*
* @package Joomla.Platform
* @subpackage Observer
* @since 3.4
*/
class JObserverWrapperMapper
{
/**
* Helper wrapper method for addObserverClassToClass
*
* @param string $observerClass The name of the observer
class (implementing JObserverInterface).
* @param string $observableClass The name of the observable
class (implementing JObservableInterface).
* @param array|boolean $params The params to give to the
JObserverInterface::createObserver() function, or false to remove mapping.
*
* @return void
*
* @see JObserverMapper::addObserverClassToClass
* @since 3.4
*/
public function addObserverClassToClass($observerClass, $observableClass,
$params = array())
{
return JObserverMapper::addObserverClassToClass($observerClass,
$observableClass, $params);
}
/**
* Helper wrapper method for attachAllObservers
*
* @param JObservableInterface $observableObject The observable
subject object.
*
* @return void
*
* @see JObserverMapper::attachAllObservers
* @since 3.4
*/
public function attachAllObservers(JObservableInterface $observableObject)
{
return JObserverMapper::attachAllObservers($observableObject);
}
}
PK[���e
interface.phpnu�[���PK[��q͏ �
Wmapper.phpnu�[���PK[Z����
updater/interface.phpnu�[���PK[��>��� Qupdater.phpnu�[���PK[�HG
(wrapper/mapper.phpnu�[���PK�r.