XCube_Delegate.class.php

<?php
 
class XCube_Ref {
    public $_mObject;

    public function __construct( &$obj ) {
        $this->_mObject =& $obj;
    }

    public function &getObject() {
        return $this->_mObject;
    }
}
 
//
// Constants for delegate priority.
// But, developers should use {first,normal,firnal} basically.
//
 
define( 'XCUBE_DELEGATE_PRIORITY_1', 10 );
define( 'XCUBE_DELEGATE_PRIORITY_2', 20 );
define( 'XCUBE_DELEGATE_PRIORITY_3', 30 );
define( 'XCUBE_DELEGATE_PRIORITY_4', 40 );
define( 'XCUBE_DELEGATE_PRIORITY_5', 50 );
define( 'XCUBE_DELEGATE_PRIORITY_6', 60 );
define( 'XCUBE_DELEGATE_PRIORITY_7', 70 );
define( 'XCUBE_DELEGATE_PRIORITY_8', 80 );
define( 'XCUBE_DELEGATE_PRIORITY_9', 90 );
define( 'XCUBE_DELEGATE_PRIORITY_10', 100 );
 
define( 'XCUBE_DELEGATE_PRIORITY_FIRST', XCUBE_DELEGATE_PRIORITY_1 );
define( 'XCUBE_DELEGATE_PRIORITY_NORMAL', XCUBE_DELEGATE_PRIORITY_5 );
define( 'XCUBE_DELEGATE_PRIORITY_FINAL', XCUBE_DELEGATE_PRIORITY_10 );
 
define( 'XCUBE_DELEGATE_CHAIN_BREAK', - 1 );

class XCube_Delegate {
    public $_mSignatures = [];

    public $_mCallbacks = [];

    public $_mHasCheckSignatures = false;

    public $_mIsLazyRegister = false;

    public $_mLazyRegisterName;

    public $_mUniqueID;

    public function __construct() {
        if ( func_num_args() ) {
            $this->_setSignatures( func_get_args() );
        }
        $this->_mUniqueID = uniqid( random_int(0, mt_getrandmax()), true );
    }

    public function _setSignatures( $args ) {
        $this->_mSignatures =& $args;
        foreach ( $args as $i => $iValue ) {
            $arg = $iValue;
            $idx = strpos( $arg, ' &' );
            if ( false !== $idx ) {
                $args[ $i ] = substr( $arg, 0, $idx );
            }
        }
        $this->_mHasCheckSignatures = true;
    }

    public function register( $delegateName ) {
        $root =& XCube_Root::getSingleton();
        if ( null !== $root->mDelegateManager ) {
            $this->_mIsLazyRegister   = false;
            $this->_mLazyRegisterName = null;
 
            return $root->mDelegateManager->register( $delegateName, $this );
        }
 
        $this->_mIsLazyRegister   = true;
        $this->_mLazyRegisterName = $delegateName;
 
        return false;
    }

    public function add( $callback, $param2 = null, $param3 = null ) {
        $priority = XCUBE_DELEGATE_PRIORITY_NORMAL;
        $filepath = null;
 
        //@gigamaster fixed to save memory
        if ( ! is_array( $callback ) && strpos( $callback, '::' ) !== false && 2 === count( $tmp = explode( '::', $callback ) ) ) {
            $callback = $tmp;
        }
 
        if ( null !== $param2 ) {
            if ( is_int( $param2 ) ) {
                $priority = $param2;
                $filepath = ( null !== $param3 && is_string( $param3 ) ) ? $param3 : null;
            } elseif ( is_string( $param2 ) ) {
                $filepath = $param2;
            }
        }
 
        $this->_mCallbacks[ $priority ][] = [ $callback, $filepath ];
        ksort( $this->_mCallbacks );
    }

    public function delete( $delcallback ) {
        foreach ( array_keys( $this->_mCallbacks ) as $priority ) {
            foreach ( array_keys( $this->_mCallbacks[ $priority ] ) as $idx ) {
                $callback = $this->_mCallbacks[ $priority ][ $idx ][0];
                if ( XCube_DelegateUtils::_compareCallback( $callback, $delcallback ) ) {
                    unset( $this->_mCallbacks[ $priority ][ $idx ] );
                }
                if ( 0 === (is_countable($this->_mCallbacks[ $priority ]) ? count( $this->_mCallbacks[ $priority ] ) : 0) ) {
                    unset( $this->_mCallbacks[ $priority ] );
                }
            }
        }
    }

    public function reset() {
        unset( $this->_mCallbacks );
        $this->_mCallbacks = [];
    }

    public function call() {
        $mSigs = [];
  $args = func_get_args();
        $num  = func_num_args();
 
        if ( $this->_mIsLazyRegister ) {
            $this->register( $this->_mLazyRegisterName );
        }
 
        if ( ( $hasSig = $this->_mHasCheckSignatures ) && (is_countable($mSigs = &$this->_mSignatures) ? count( $mSigs = &$this->_mSignatures ) : 0) !== $num ) {
            return false;
        }
 
        for ( $i = 0; $i < $num; $i ++ ) {
            $arg = &$args[ $i ];
            if ( $arg instanceof XCube_Ref ) {
                $args[ $i ] =& $arg->getObject();
            }
 
            if ( $hasSig ) {
                if ( ! isset( $mSigs[ $i ] ) ) {
                    return false;
                }
                switch ( $mSigs[ $i ] ) {
                    case 'void':
                        break;
 
                    case 'bool':
                        if ( ! empty( $arg ) ) {
                            $args[ $i ] = $arg ? true : false;
                            // $args[ $i ] = (bool)$arg; // Test replace with (bool)
                        }
                        break;
 
                    case 'int':
                        if ( ! empty( $arg ) ) {
                            $args[ $i ] = (int) $arg;
                        }
                        break;
 
                    case 'float':
                        if ( ! empty( $arg ) ) {
                            $args[ $i ] = (float) $arg;
                        }
                        break;
 
                    case 'string':
                        if ( ! empty( $arg ) && ! is_string( $arg ) ) {
                            return false;
                        }
                        break;
 
                    default:
                        if ( ! is_a( $arg, $mSigs[ $i ] ) ) {
                            return false;
                        }
                }
            }
        }
 
        foreach ( $this->_mCallbacks as $callback_arrays ) {
            foreach ( $callback_arrays as $callback_array ) {
                [$callback, $file] = $callback_array;
 
                if ( $file ) {
                    require_once $file;
                }
                if ( is_callable( $callback ) && XCUBE_DELEGATE_CHAIN_BREAK === call_user_func_array( $callback, $args ) ) {
                    break 2;
                }
            }
        }
    }

    public function isEmpty() {
        return ( 0 === count( $this->_mCallbacks ) );
    }

    public function getID() {
        return $this->_mUniqueID;
    }
}

class XCube_DelegateManager {
    public $_mCallbacks = [];

    public $_mCallbackParameters = [];

    public $_mDelegates = [];

    public function __construct() {
    }

    public function register( $name, &$delegate ) {
        $mDelegate =& $this->_mDelegates[ $name ];
        if ( isset( $mDelegate[ $id = $delegate->getID() ] ) ) {
            return false;
        }
 
        $mDelegate[ $id ] =& $delegate;
 
        $mcb = &$this->_mCallbacks[ $name ];
        if ( isset( $mcb ) && (is_countable($mcb) ? count( $mcb ) : 0) > 0 ) {
            foreach ( $mcb as $key => $func ) {
                [$a, $b] = $this->_mCallbackParameters[ $name ][ $key ];
                $delegate->add( $func, $a, $b );
            }
        }
 
        return true;
    }

    public function add(string $name, $callback, $param3 = null, $param4 = null ) {
        if ( isset( $this->_mDelegates[ $name ] ) ) {
            foreach ( $this->_mDelegates[ $name ] as $func ) {
                $func->add( $callback, $param3, $param4 );
            }
        }
        $this->_mCallbacks[ $name ][]          = $callback;
        $this->_mCallbackParameters[ $name ][] = [ '0' => $param3, '1' => $param4 ];
    }

    public function delete(string $name, $delcallback ) {
        if ( isset( $this->_mDelegates[ $name ] ) ) {
            foreach ( array_keys( $this->_mDelegates[ $name ] ) as $key ) {
                $this->_mDelegates[ $name ][ $key ]->delete( $delcallback );
            }
        }
        if ( isset( $this->_mCallbacks[ $name ] ) ) {
            foreach ( array_keys( $this->_mCallbacks[ $name ] ) as $key ) {
                $callback = $this->_mCallbacks[ $name ][ $key ];
                if ( XCube_DelegateUtils::_compareCallback( $callback, $delcallback ) ) {
                    unset( $this->_mCallbacks[ $name ][ $key ], $this->_mCallbackParameters[ $name ][ $key ] );
                }
            }
        }
    }

    public function reset(string $name ) {
        if ( isset( $this->_mDelegates[ $name ] ) ) {
            foreach ( array_keys( $this->_mDelegates[ $name ] ) as $key ) {
                $this->_mDelegates[ $name ][ $key ]->reset();
            }
        }
        if ( isset( $this->_mCallbacks[ $name ] ) ) {
            unset( $this->_mCallbacks[ $name ], $this->_mCallbackParameters[ $name ] );
        }
    }

    public function isEmpty(string $name ) {
        if ( isset( $this->_mDelegates[ $name ] ) ) {
            return $this->_mDelegates[ $name ]->isEmpty();
        }
 
        return isset( $this->_mCallbacks[ $name ] ) ? ( 0 === (is_countable($this->_mCallbacks[ $name ]) ? count( $this->_mCallbacks[ $name ] ) : 0) ) : false;
    }

    public function getDelegates() {
        return $this->_mDelegates;
    }
}

class XCube_DelegateUtils {
    public function __construct() {
    }
 
    public static function call() {
        $args = func_get_args();
        $num  = func_num_args();
        if ( 1 === $num ) {
            $delegateName = $args[0];
        } elseif ( $num ) {
            $delegateName = array_shift( $args );
        } else {
            return false;
        }
        $m =& XCube_Root::getSingleton()->mDelegateManager;
        if ( $m ) {
            $delegates = $m->getDelegates();
            if ( isset( $delegates[ $delegateName ] ) ) {
                $delegates = &$delegates[ $delegateName ];
                [$key] = array_keys( $delegates );
                $delegate =& $delegates[ $key ];
            } else {
                $delegate = new XCube_Delegate();
                $m->register( $delegateName, $delegate );
            }
        }
 
        return call_user_func_array( [ &$delegate, 'call' ], $args );
    }

    public static function raiseEvent() {
        if ( func_num_args() ) {
            $args = func_get_args();
 
            return call_user_func_array( [ 'XCube_DelegateUtils', 'call' ], $args );
        }
    }

    public static function applyStringFilter() {
        $args = func_get_args();
        $num  = func_num_args();
        if ( $num > 1 ) {
            $delegateName = $args[0];
            $string       = $args[1];
            if ( ! empty( $string ) && is_string( $string ) ) {
                return '';
            }
            $args[1] = new XCube_Ref( $string );
            call_user_func_array( [ 'XCube_DelegateUtils', 'call' ], $args );
 
            return $string;
        }
 
        return '';
    }

    public static function _compareCallback( $callback1, $callback2 ) {
        if ( ! is_array( $callback1 ) && ! is_array( $callback2 ) && ( $callback1 === $callback2 ) ) {
            return true;
        }
        if ( is_array( $callback1 ) && is_array( $callback2 ) && ( gettype( $callback1[0] ) === gettype( $callback2[0] ) )
             && ( $callback1[1] === $callback2[1] ) ) {
            if ( ! is_object( $callback1[0] ) && ( $callback1[0] === $callback2[0] ) ) {
                return true;
            }
            if ( is_object( $callback1[0] ) && ( get_class( $callback1[0] ) === get_class( $callback2[0] ) ) ) {
                return true;
            }
        }
 
        return false;
    }
}