Nuevos tipos de datos: Struct de C y Range

[Italico76]

Iniciado por pateketrueke

Suena interesante, me pregunto si la extensión SPL de PHP no implementa algo parecido.

Digo, PHP ha evolucionado mucho y no me sorprendería que exista algo similar, en caso de no existir veo elegante tu implementación.

Mucha gracias por las flores


VERSION ACTUALIZADA DE "STRUCT":

Código PHP:

<?php
/*
    Struct as in C
    @author: Pablo Bozzolo
 
    struct database {
        int id_number;
        int age;
        float salary;
    };
*/
 
Class Struct
{
    protected $_field = array();
    protected $_type  = array();
    protected $_name = null;
    protected $_type_hinting = true;    
    protected $_tipos_ = array ("boolean","integer","double","string","array","object","resource","NULL" );
    protected $_aliases = array();  
    
    /* setter on-off */
    public function alias($flag=true)
    {
        if ($flag)
            $this->_aliases=array('bool'=>'boolean','int'=>'integer','float'=>'double','str'=>'string');
        else
            $this->_aliases=null;
            
        return $this;   
    }
        
    public function __construct($name)
    {
        $this->_name=$name;
        $this->alias();
    }
    
    // sin implentar
    public function __clone()
    {   }
 
    public function typeHinting($flag)
    {
        $this->_type_hinting=$flag;         
    }
    
    public function parse($str)
    {
        $patt = '|^[\s]{0,}([a-z_]*)[\s]{0,}([$]?[a-z_]*[0-9a-z]*)[\s]{0,}[=;]?[\s]{0,}(.*)|i';
        
        $statements = explode(';',trim($str));
        foreach ($statements as $st)
        {       
            if (strlen($st)==0)
                continue;
                
            if (preg_match($patt,$st,$resul))
            {
                $type = $resul[1];
                $var_name = str_replace('$','',$resul[2]);
                $default = $resul[3];               
                                
                if ( (empty($var_name)) and (!empty($type)) )
                {
                    $var_name=$type;
                    $type=null;
                }
                
                $this->create($var_name,$type,$default);                                
            }else
                echo "FAIL PARSING : $st \n";;
        }
        return $this;
    }
 
    public function create($var,$type=null,$val=null)
    {
        if ((!empty($type)) and ($type!="unknown type"))
        {       
            // alias
            foreach ((array) $this->_aliases as $alias => $typo)
                if ($type==$alias) $type=$typo;
                        
            if ((in_array($type,$this->_tipos_)))
                $this->_type[$var] = $type; 
            else
                throw new Exception ("Tipo de dato no soportado");      
        }               
                
    
        $this->_field[$var] = $val;     
        return $this;
    }
    
    
    public function __set($var,$val)
    {       
        if (!empty($this->_type[$var]))
            if (gettype($val)!= $this->_type[$var])
                throw new Exception ("Tipos no coinciden");     
    
        if (in_array($var,array_keys($this->_field)))
            $this->_field[$var] = $val;     
        else
            throw new Exception("No existe el campo $var!");
    }
    
    public function __get($var)
    {
        return $this->_field[$var];             
    }
}
 

A considerar si se usa parse()

1.- Las propiedades del struct pueden o no comenzar con $ como las variables (opcional)

2.- No se admiten ningun tipo de comentario inline ni multiline (no molesten xD)

--
Aca un tema viejito donde me surgio la idea de la clase Range