source: sandbox/2.2.0.2/API/class.servicelocator.php @ 4445

<?php

//Helper function and defines that must be moved to a common area
/////////////////////////////////////////////////////

if(!function_exists('define_once') )
{
    function define_once( $constant, $value )
    {
        if( !defined( $constant ) )
        {
            define( $constant, $value );
        }
    }
}

define_once( 'ROOT', $_SESSION['rootPath'].'/' );

define_once( 'SERVICES', ROOT.'/services/' );

define_once( 'LIBRARY', ROOT.'/library/' );

define_once( 'API', ROOT.'/API/' );

if( !class_exists('ServiceLocator') ){

/////////////////////////////////////////////////////
class ServiceLocator
{
    static $locators = array();

    static $cache = array();

    //$service = null;

    //$serviceName = null;

//     static $empty_locator = new ServiceLocator( 'empty' );

    static function load( $configuration )
    {
        $configuration = SERVICES.$configuration;

        if( !file_exists ( $configuration ) )
        return( false );

        $configuration = parse_ini_file( $configuration );

        foreach( $configuration as $serviceType => $serviceName )
        {
            self::deploy( $serviceType, $serviceName );
        }
    }

    static function deploy( $serviceType, $serviceName = null )
    {
        require_once( SERVICES."class.".$serviceType.".php" );

        if( $serviceName )
        {
            self::register( $serviceType, new $serviceName() );
        }

        return( self::$locators[ $serviceType ] );
    }

    //make all the treatment of
    static function register( $service, $object )
    {
        self::$locators[ $service ] = new ServiceLocator( $service, $object );

        self::configure( $service );

        return( self::$locators[ $service ] );
    }

    static function unregister( $service )
    {
        $old = self::$locators[ $service ];

        unset( self::$locators[ $service ] );

        return( $old );
    }

    //implement
    static function configure( $service )
    {
        return( null );
    }

    static function locate( $service, $arguments = array(), $target = false )
    {
        if( !$target )
        {
            list( $target, $service ) = explode( ".", $service );
        }

        if( !is_array( $arguments ) )
        {
            $arguments = array( $arguments );
        }

        $locator = self::$locators[ $target ];

        if( !$locator )
        {
            $locator = self::deploy( $target );
        }
        if( !$locator )
        {
            return( false );
        }

        try
        {
            return $locator->proxy( $service, $arguments );
        }
        catch( Exception $e )
        {
            //Implement the exception stack to the fallback handlers treat correctly
            //by now - fly it
        }
        
        return( null );
    }

    function __construct( $serviceName, $object )
    {
        $this->service = $object;
        $this->serviceName = $serviceName;
    }

    function proxy( $method, $arguments )
    {
        //handle here cases of miss of methods
        if( !method_exists( $this->service, $method ) ) return( false );

        $many = count( $arguments );

        $proxy = self::$cache[$many];

        if( !$proxy )
        {
            $params = array();

            for( $i = 0; $i < $many; $params[] = '$params['.$i++.']' );

            $proxy = create_function( '$method, $params, $obj', 'return $obj->$method('.implode( ', ', $params ).');' );

            self::$cache[$many] = $proxy;
        }

        if( !isset( $arguments ) ) return( $proxy );

        return $proxy( $method, $arguments, $this->service );
    }

    function call()
    {
        $arguments = func_get_args();

        $service = array_pop( $arguments );

        //handle here dispatch with invalid services
        if( $this )
        {
            $service = strrpos( $service, "." ) ? $service : $this->serviceName.".".$service;
        }

        return self::locate( $service, $arguments );
    }

    function dispatch( $service, $arguments )
    {
        //handle here dispatch with invalid services
        if( $this )
        {
            $service = strrpos( $service, "." ) ? $service : $this->serviceName.".".$service;
        }

        return self::locate( $service, $arguments );
    }

    function __call( $method, $arguments )
    {
        return self::locate( $method, $arguments, $this->serviceName );
    }

    function __get( $name )
    {
        return $this->service->$name;
    }

    static function __callStatic( $method, $arguments )
    {
        return self::locate( $method, $arguments );
    }

    static function getService( $service )
    {
        if( !self::$locators[ $service ] )
        {
            self::deploy( $service );
        }

        return( clone self::$locators[ $service ] );
    }
}

}

//estudar uma forma mais elegante de carregar os servicos
//ServiceLocator::load( "services.conf" );

?>