x sirdaniel: grazie per lo script. lo sto valutando

x dottwatson

Premesso che non sono in studio e non ho i sorgenti sui quali sto lavorando qua con me ho riscostruito un pò alla buona quanto fatto fino adesso.

Codice PHP:
<?php

class autoloadClass
{

    
// In sostanza il costruttore non fa altro che smistare i file da includere
    // ai metodi stabiliti passando di volta volta i parametri necessari.
    // Se $p è settata il metodo instanceClass(); instanzia la classe passandogli
    // i parametri (questa è la parte rognosa).
    
public static function autoLoad ($path$type$bool=NULL$var=NULL)
    
        switch (
$type)
        {
        
            case 
'FILE':
                
self::fileInclude($path);
                break;
            
            case 
'CLASS':
                if (
$bool == TRUE)
                {
                
                    
$p 1;
                    
self::classInclude($path$var$p);
                
                } else {
                
                    
self::classInclude($path);
                    
                }
                break;
                
            case default:
                break;
                
        }
        
    
// Questo metodo crea solamente i percorsi per le inclusioni
    
public static function fileInclude ($path)
    {
    
        
$path explode '.'$path ); 
        
            
$suffix $path[0];
            
$path = unset(sort($path)); // Non sono sicuro funzionino combinate così.
            
            // Utilizzo un altro ciclo switch per determinare dove devono andare a finire
            // i file da includere
            
switch '$suffix'
            
{
            
                case 
'img':
                
                    
self::imageLoad($path);
                case 
'i':
                    
self::iInclude($path);
                    break;
                    
                case 
'io':
                    
self::ioInclude($path);
                
                case 
'r':
                    
self::rInclude($path);
                    
                case 
'ro':
                    
self::roInclude($path);
                    
                case default:
                    break;
                    
              }
              
    }
        
    
// Come il precedente
    
public static function classInclude ($path$var$p)
    {
    
        
$path explode '.'$path ); 
        
            
$suffix $path[0];
            
$path = unset(sort($path)); // Non sono sicuro funzionino combinate così.
            
            // Utilizzo un altro ciclo switch per determinare dove devono andare a finire
            // i file da includere e verifico che sia settata $p. Se lo è gli passo anche
            // i parametri per instanziare la classe. Essendo certo che sto includendo una
            // classe non mi curo di controllare che il suffisso sia img perchè non può
            // esserlo a meno di errori di scrittura.
            
switch '$suffix'
            
{
            
                case 
'i':
                    (isset(
$p)) ? self::iInclude($path$var$p) : self::iInclude($path);
                    break;
                    
                case 
'io':
                    (isset(
$p)) ? self::ioInclude($path$var,$p) : self::ioInclude($path);
                    break;
                
                case 
'r':
                    (isset(
$p)) ? self::rInclude($path$var$p) : self::rInclude($path);
                    break;
                    
                case 
'ro':
                    (isset(
$p)) ? self::roInclude($path$var$p) : self::roInclude($path);
                    break;
                    
                case default:
                    break;
                    
              }
              
    }
    
    
// Adesso passo a scrivere i metodi per l'inclusione.
    // include
    
public static function iInclude($path$var=NULL$p=NULL)
    {
    
        if (isset(
$p)) { 
            include 
$path;
            
self::classInstance($path$var$p);
        } else {
            include 
$path;
        }
        
    }
    
    
// include_once
    
public static function ioInclude ($path$var=NULL$p=NULL)
    {
        if (isset(
$p)) { 
            include_once 
$path;
            
self::classInstance($path$var$p);
        } else {
            include_once 
$path;
        }
    
    }    
    
// require
    
public static function rInclude ($path$var=NULL$p=NULL)
    {
        if (isset(
$p)) { 
            require 
$path;
            
self::classInstance($path$var$p);
        } else {
            require 
$path;
        }
    
    }    
    
// require_once
    
public static function roInclude ($path$var=NULL$p=NULL)
    {
        if (isset(
$p)) { 
            require_once 
$path;
            
self::classInstance($path$var$p);
        } else {
            require_once 
$path;
        }
    
    }

public static function 
classInstance($path$var$p)
    {

    
// Questo metodo mi sta facendo impazzire
    // In sostanza devo:
    
    // Primo passo
    // Contare gli elementi del array contenente i parametri da passare alla classe
    
$parms explode (' '$var);
    
$count count($parms); 
    
// Adesso dovrei trovare il modo di produrre, per ogni elemento del array
    // una variabile con il suo nome contenente i dati.
    // Es: se la chiave 1 è uguale a root dovrei fare un assegnazione di questo
    // tipo $root = root; 
    
    // Secondo passo
    // Estrarre il nome della classe contenuto in $path
    
$tokens token_get_all($path);
        
$class_def FALSE;
        
$classes = array();
    
        foreach ( 
$tokens as $token ) {
                if ( 
$token[0] == T_CLASS )
                   
$class_def TRUE;
                if ( 
$class_def AND $token[0] == T_STRING ) {
                        
$classes[] = $token[1];
                        
$class_def FALSE;
                }
            }

        return 
$classes// In $classes dovrei avere il nome della classe

    
if (isset($p))
    {
    
        
// Ora dovrei fare un qualcosa di simile a:
        
$classes = new $classes ('/** Qua dovrebbero andarci i parametri e non so come metterceli */ ');
        
    } elseif {
    
        
$classes = new $classes ();
    
    }

}

?>
Qualche idea ?
Adriano