Strict Standards: Only variables should be assigned by reference in ... on line 40

        >> private function __construct()

        >> ...

        >>      self::$CONSTRUCTEUR =& ILLI_Constructeur::init($this);

 

Strict Standards: Only variables should be assigned by reference in ... on line 59

        >> public static function init()

        >> ...

        >>      self::$SELF =& new self;

 

 

        FINAL CLASS ILLI

        {

       

                private static $SELF         = NULL;

                private static $CONSTRUCTEUR = NULL;

               

                private function __clone(){}

               

                private function __construct()

                {

                        self::$CONSTRUCTEUR =& ILLI_Constructeur::init($this);

                }

               

                public static function init()

                {

                        set_include_path

                        (

                                implode

                                (

                                        PATH_SEPARATOR,

                                        array

                                        (

                                            realpath(dirname(__FILE__).'/VENDOR'),

                                            get_include_path()

                                        )

                                )

                        );

                       

                        if(is_null(self::$SELF))

                                self::$SELF =& new self;

                               

                        return self::$SELF;

                }

               

                public function run()

                {

                        self::$CONSTRUCTEUR->run($this);

                }

               

                public function get_Constructeur()

                {

                        return self::$CONSTRUCTEUR;

                }

               

        }

 

 

 

Strict Standards: Assigning the return value of new by reference is deprecated in ... on line 115

        >> public static function init(ILLI $ILLI)

        >> ...

        >> if(NULL === self::$SELF)

        >>      self::$SELF =& new self;

 

        FINAL CLASS ILLI_Constructeur

        {

                private static $Instances     = NULL;

                private static $SELF          = NULL;

                private static $initialized   = FALSE;

                private static $executed      = FALSE;

               

                private static $applicationProfile        = '';

 

                private function __construct()

                {      

                        self::$Instances = new ILLI_Container;

                       

                        self::set_Instance(new ILLI_Container_Configuration)

                       

                                // register the accepted offset-types for all settings

                       

                                // name of application

                                // this allows you to use a single-installation of ILLI for several apps; default is localhost

                                -> set_Rule('string','APPLICATION_PROFILE')

                               

                                // min/max-php-version

                                -> set_Rule('string','PHP_MIN_VERSION', array('5.2'))

                                -> set_Rule('string','PHP_MAX_VERSION', array('6'))

                               

                                // php-ini

                                -> set_Rule('array', 'PHP_INI')

                               

                                // aparse incoming get-vars

                                // todo: move that into routing

                                -> set_Rule('array', 'CLEANVARS_GET')

                                // accepted vars, but hide for parsing

                                -> set_Rule('array', 'CLEANVARS_GET_IGNORE')

                                // allow ILLI to kill all unregistred vars

                                -> set_Rule('bool',  'CLEANVARS_GET_DISCARD_UNREGISTERED')

                                // allow only incoming get if client accept session-cookie

                                -> set_Rule('bool',  'CLEANVARS_GET_DISCARD_ALL_ON_MISSING_SESSIONCOOKIE')

                               

                                // aparse incoming post-vars

                                // todo: move that into routing

                                -> set_Rule('array', 'CLEANVARS_POST')

                                // accepted vars, but hide for parsing

                                -> set_Rule('array', 'CLEANVARS_POST_IGNORE')

                                // allow ILLI to kill all unregistred vars

                                -> set_Rule('bool',  'CLEANVARS_POST_DISCARD_UNREGISTERED')

                                // allow only incoming post if client accept session-cookie

                                -> set_Rule('bool',  'CLEANVARS_POST_DISCARD_ALL_ON_MISSING_SESSIONCOOKIE')

                               

                                // env-mode-tolerance; defaults are PRODUCTION and DEVELOPMENT

                                -> set_Rule('string','ENVIRONMENT_MODE', array('PRODUCTION','DEVELOPMENT'))

                               

                                // url-deep-path; for root set = '/'

                                -> set_Rule('string','BASE_DEVELOPMENT')

                                -> set_Rule('string','BASE_PRODUCTION')

                               

                                // select layout-dir for view

                                -> set_Rule('string','LAYOUT')

                               

                                // show errors and exception only for defined i.p.

                                -> set_Rule('array', 'DEVELOPMENT_IP')

                               

                                // will redirect all requests to self-repaired, clean uri

                                -> set_Rule('bool',  'FORWARD_TO_REPAIRED_URI')

                               

                                // page-encoding; this is global for pageoutput and form-accepted-charset

                                -> set_Rule('string','ENCODING')

                               

                                // set cache timeouts for filetypes

                                // @to0do: move that value into routing-table

                                -> set_Rule('array', 'CLIENT_CACHE_CONTROL_MAX_AGE')

                                -> set_Rule('array', 'CLIENT_CACHE_PRAGMA_CACHE');

                }

               

               

                public static function get_Instance($name)

                {

                        if(!isset(self::$Instances->{'_'.$name}))

                                self::set_Instance(new $name);

                                       

                        return self::$Instances->{'_'.$name};

                }

               

               

                public static function set_Instance(ILLI_Container_Interface $instance)

                {

                        try

                        {

                                if(isset(self::$Instances->{'_'.get_class($instance)}))

                                        throw new Exception

                                                (get_class($instance).' already initialized.');

                        }

                        catch(ILLI_Constructeur_Exception $e){$e->w();}

                                               

                        self::$Instances->{'_'.get_class($instance)} = $instance;                      

                        return self::get_Instance(get_class($instance));

                }

               

                /**

                public static function init(ILLI $ILLI)

                {

                        try

                        {

                                if(FALSE === self::$initialized)

                                        self::$initialized = TRUE;

                                else throw new ILLI_Constructeur_Exception

                                        ('ILLI already initialized..');

 

                                if(NULL === self::$SELF)

                                        self::$SELF =& new self;

                                       

                                //self::$SELF->setup();

 

                                return self::$SELF;

                        }

                        catch(ILLI_Constructeur_Exception $e){$e->w();}

                }

               

                /**

                public function run(ILLI $ILLI)

                {

                        try

                        {

                                if(FALSE === self::$initialized)

                                        throw new ILLI_Constructeur_Exception

                                                ('ILLI not initialized..');

 

                                if(FALSE === self::$executed)

                                        self::$executed = TRUE;

                                else throw new ILLI_Constructeur_Exception

                                        ('Can not execute ILLI again.');

                        }

                        catch(ILLI_Constructeur_Exception $e){$e->w();}

 

                        return self::$SELF;

                }

        }