PHP Classes

File: shutdownManager.php

Recommend this page to a friend!
  Classes of Jonathan Gotti   Simple MVC Shutdown Manager   shutdownManager.php   Download  
File: shutdownManager.php
Role: Class source
Content type: text/plain
Description: main class source
Class: Simple MVC Shutdown Manager
Manage PHP script shutdown functions
Author: By
Last change:
Date: 12 years ago
Size: 4,083 bytes
 

Contents

Class file image Download
<?php
/**
* @package simpleMVC
* @class smvcShutdownManager
* @since 2010-12-20
* @licence dual licence LGPL / MIT
* @author jonathan gotti <jgotti at jgotti dot net>
*/
class smvcShutdownManager{

    static private
$_registeredCallbacks = array();
    static private
$_byPassCallBacks = false;
    static private
$_registered = false;
    static private
$_id = 0;

   
/**
    * Check that given callable is registered by shutdown manager. It also allow to check that smvcShutdownManager is registered itself
    * @param callback $callBack check that the given callback (or id of registered callback return by register method) is registered (if null then check that smvcShutdownManager itself is registered)
    * @param bool $returnPriority if true the actual priority level of the callback will be return instead of bool (be aware it may return 0 in such case that doesn't mean false)
    * @return bool or integer if $returnPriority is passed to true
    */
   
static public function isRegistered($callBack=null,$returnPriority=false){
        if(
null === $callBack ){
            return
self::$_registered;
        }

        if(
is_int($callBack) ){
            return isset(
self::$_registeredCallbacks[$callBack])?($returnPriority?self::$_registeredCallbacks[$callBack][1]:true):false;
        }

        foreach(
self::$_registeredCallbacks as $cb){
            if(
$cb[0]===$callBack)
                return
$returnPriority?$cb[1]:true;
        }
        return
false;
    }

   
/**
    * register a callback function to be executed as a shutdown fucntion
    * @param callback $callBack the callback to register, if already registered then it
    * @param int $priority the priority level of the callback (higher level means later call)
    * @param mixed $param you can add as many optionnal parameter as you want to the callback
    * @return int internal callback id
    */
   
static public function register($callBack,$priority=0){
        if(!
self::$_registered ){
           
register_shutdown_function(array(__class__,'_registered_shutdown'));
           
self::$_registered = true;
        }
       
$params = func_get_args();
       
self::$_registeredCallbacks[++self::$_id] = array($callBack,(int) $priority,self::$_id,array_slice($params,2));
        return
self::$_id;
    }

   
/**
    * unregister previously registered callback
    * @param callback $callBack the callback to unregister (or the callback id returned by register method )
    * /!\ if null is given then will unregister all previously registered callback.
    * @return bool return true if successfully removed else return false
    */
   
static public function unregister($callBack){
        if(
is_null($callBack) ){
           
self::$_registeredCallbacks = array();
            return
true;
        }
        if(
is_int($callBack) ){
            if( !isset(
self::$_registered[$callBack]))
                return
false;
            unset(
self::$_registered[$callBack]);
            return
true;
        }
        foreach(
self::$_registeredCallbacks as $k=>$cb){
            if(
$cb[0]===$callBack){
                unset(
self::$_registeredCallbacks[$k]);
                return
true;
            }
        }
        return
false;
    }

   
/**
    * shutdown the script by calling exit.
    * @param mixed $status may be a string as in die or a status code (@see exit)
    * @param bool $byPassCallBacks if true then will do a normal exit without calling any of the registered callbacks
    */
   
static public function shutdown($status=0,$byPassCallBacks=false){
       
self::$_byPassCallBacks = $byPassCallBacks;
        exit(
$status?$status:0);
    }

   
/**
    * THIS IS NOT INTENTED TO BE CALLED OTHER THAN INTERNALLY
    * the only reason for this to be public is that it's a necessity for register_shutdown_function to see it
    * there's no reason at all for you to call this
    * @internal
    */
   
static public function _registered_shutdown(){
        if(
self::$_byPassCallBacks )
            return;
       
#- first sort the stack
       
uasort(self::$_registeredCallbacks,array(__class__,'_compare'));
        foreach(
self::$_registeredCallbacks as $cb){
           
call_user_func_array($cb[0],$cb[3]);
        }
    }

   
/**
    * used to sort callbacks by priority respecting their registering order
    * @internal
    * @private
    */
   
static private function _compare($a,$b){
        if(
$a[1] === $b[1] ){
            return
$a[2] > $b[2]?1:-1;
        }
        return
$a[1] > $b[1]?1:-1;
    }
}