Login   Register  
PHP Classes
elePHPant
Icontem

File: shutdownManager.php

Recommend this page to a friend!
Stumble It! Stumble It! Bookmark in del.icio.us Bookmark in del.icio.us
  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: 3 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;
    }
}