Nuevos tipos de datos: Struct de C y Range

[Italico76]

Buenas,

Hay tipos de datos que en alguna circunstancia he necesitado demasiado y aqui les dejo la implementacion:


TIPO STRUCT (sacado de lenguaje C)

La idea es tener una estructura rigida que no permita creas indices por error como en el caso de un array o propiedades publicas en el caso de una clase solo por error

Se usaria asi:

Código PHP:

  // creo la estructura 
$st_per = (new Struct('persona')); 
$st_per    ->create('nombre','str','NN') 
        ->create('apellido','str') 
        ->create('edad','int') 
        ->create('sexo_masc','bool',true) 
        ->create('hijos','bool',false) 
        ->create('fecha_aniversario','object',null) 
        ->create('telefonos','array');         
 
         
// creo tantos registros como necesito 
$per1 = clone $st_per;         
$per2 = clone $st_per;         
         
             
// la uso :) 
$per1->nombre  = 'Pablo';     
$per1->apellido  = 'Bozzolo';     
$per1->edad = 32; 
$per1->fecha_aniversario = (new Datetime)->setDate (1980,1,10); 
$per1->telefonos=array('301 203 4445','300 434 5564'); 
#$per1->sexo_masc = 'h';  // Excepcion  
#$per1->direccion = 'en mi casa'; // Excepcion 
 
$per2->nombre  = 'Maria';     
$per2->apellido  = 'Mosconi';     
$per2->edad = 19; 
$per2->fecha_aniversario = (new Datetime)->setDate (2006,2,23); 
$per2->telefonos=array('600 455 554'); 
$per2->sexo_masc = false;   
$per2->hijos = true;  
   

Y la Clase que lo implementa es:

Código PHP:

   
/* 
    Struct as in C 
    @author: Pablo Bozzolo 
 
    struct database { 
        int id_number; 
        int age; 
        float salary; 
    }; 
*/ 
Class Struct 
{ 
    private $_field = array(); 
    private $_type  = array(); 
    private $_name = null; 
     
    private $_tipos_ = array ("boolean","integer","double","string","array","object","resource","NULL" ); 
         
    public function __construct($name) 
    { 
        $this->_name=$name; 
    } 
     
    // sin implentar 
    public function __clone() 
    { } 
     
     
    // sin implentar 
    public function parse($str) 
    { } 
 
    public function create($var,$type=null,$val=null) 
    { 
        if ((!empty($type)) and ($type!="unknown type")) 
        { 
            // alias 
            if ($type=='bool') $type='boolean'; 
            if ($type=='int') $type='integer';                 
            if ($type=='float') $type='double';     
            if ($type=='str') $type='string';     
             
            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 (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];                 
    } 
}  
   

Habia pensado en implementar un metodo parse() para cambiar la sintaxis pero me parecio demasiada sobrecarga (quizas no)... y lo dejo asi por ahora:

Se usaba asi:

Código PHP:

  /* Experimental */ 
 
$st_diccio = (new Struct('alquiler videos'))->parse(' 
    string $pelicula; 
    object    $nom_persona; 
    object $fecha_prestamo; 
    int    $dias_prestamo = 3; 
');  
   

Tener en cuenta que uso alias para integer (int), string (str), float (double) ... tambien habia pensado en dar la opcion de deshabilitar el alias pero de momento queda asi

CRITIQUEN POR FAVOR... !

[Italico76]

TIPO RANGE

Permite manejar un tipo de dato rango que ademas es iterable (implementa Iterator):

Código PHP:

  $rango = new Range(1,100,2);

foreach ($rango as $valor){
    echo "$valor\n";
}

echo $rango; 
echo str_replace (' ',' ,',$rango);  
   

Quien lo implementa:

Código PHP:

  <?php 

/*
    Clase Range
    @author: Pablo Bozzolo (italico76)
*/
Class Range implements Iterator {

    private $_arr = [];
    private $_ini  = null;
    private $_end  = null;
    private $_step = null;

    public function __construct($a,$b,$step=null){        
        $this->_ini  = $a;
        $this->_end  = $b;
        $this->_step = ($step == null ? 1 : $step);
        $this->_arr  = range($this->_ini,$this->_end,$this->_step);
    }

    public function getArray(){
        return $this->_arr;
    }

    public function __toString(){        
        $out = null; 

        foreach ($this->_arr as $val)
            $out .= "$val ";
     
        return rtrim($out);
           
    }

    /* Implemento interface Iterator  */

    public function rewind()
    {        
        reset($this->_arr);
    }

    public function current()
    {
        $elem = current($this->_arr);        
        return $elem;
    }

    public function next()
    {
        $elem = next($this->_arr);        
        return $elem;
    }
      
    public function key()
    {     
        $key = key($this->_arr); 
        return $key;
    }
  
    public function valid()
    {
        $key = key($this->_arr);
        $elem = ($key !== NULL && $key !== FALSE);        
        return $elem;
    }  

} // endClass   

[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.

[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

[lolainas]

Buen y curioso artificio los structs

Respecto a los ranges, para los que tengáis la suerte de escribir en las últimas versiones de PHP (como yo!!), esto es muy interesante

(PHP 5 >= 5.5.0)
Los generadores proporcionan un modo fácil de implementar iteradores simples sin la sobrecarga o complejidad de implementar una clase que implemente la interfaz Iterator.

Un generador permite escribir código que utilice foreach para iterar sobre un conjunto de datos sin que sea necesario cargar el array en memoria, lo que puede ocasionar que se exceda el límite de memoria, o requiera una cantidad considerable de tiempo de procesado para generarse. En su lugar, se puede escribir una función generadora, que es igual que una función normal, con la salvedad de que en vez de hacer un solo return, un generador puede invocar yield tantas veces como necesite para proporcionar valores por los que iterar.

Un ejemplo simple de esto es reimplementar la función range() como un generador. La función estándar range() tiene que generar un array con cada uno de los valores y devolverlo, lo que puede resultar en arrays grandes: por ejemplo, llamar range(0, 1000000) resultará en más de 100 MB de memoria utilizada.

Como alternativa, se puede implementar un generador xrange(), que sólo necesitará memoria para crear un objeto Iterator y controlar el estado actual del generador de manera interna, lo que no ocupa más de 1 kilobyte.

[lolainas]

Apuntes sobre struct (constructivos, por las dudas)

1. Partiendo de la base de que los structs en C son declarados en tiempo de compilación y no de ejecución, dejaría de usar create para ello.

2. En el type hinting quizás el tipo 'object' sea muy genérico y fácilmente franqueable, sería de utilidad usar el operador de tipo instanceof, además de gettype para tipos primitivos.

Código PHP:

abstract class Struct {
 
    private $data;
    private $definition;
 
    function __construct(array $definition) {
        $this->definition = $definition;
    }
 
    function __get($name) {
        return $this->data[$name];
    }
 
    function __set($name, $value) {
        if (isset($this->definition[$name]))
            if (($value_type = gettype($value)) === ($definition_type = $this->definition[$name]) || $value instanceof $definition_type)
                $this->data[$name] = $value;
            else
                throw new Exception("Trying to assign ({$definition_type}: {$name}) with {$value_type}");
        else
            throw new Exception("Trying to access undefined variable {$name}");
    }
 
}
 
class Persona extends Struct {
 
    function __construct() {
        parent::__construct([
            'nombre'           => 'string',
            'apellidos'        => 'string',
            'fecha_nacimiento' => 'DateTime',
            'telefonos'        => 'array'
        ]);
    }
 
}
 
$p = new Persona;
 
$p->nombre = 'Pablo';
$p->apellidos = 'Bozzolo';
$p->fecha_nacimiento = new DateTime('1980-10-01');
$p->telefonos = ['435435435', '342343242'];
 
var_dump($p);
 

Que conste que este tipo de aritificios no están garantizados para un entorno de producción real, pero es un tema interesante al que últimamente se le da mucha vuelta por el foro, por ejemplo este artificio para emular polimorfismo del amigo NSD.

Saludos.

[Italico76]

@lolainas : que te digo ? tu version funciona, es mas simple..... me gusta y mucho excepto porque la forma de utilizarla es mucho mas complicada, toca crear una clase y escribir un su constructor una llamada al constructor del padre Struct con un array tambien hecho a mano.


Como me destacaba por MP el compañero @hhs ... es importante ofrecer una "API simple", igualmente me tome el atrevimiento de "mejorar" un poco tu version y agregarle el alias de tipos:

Código PHP:

abstract class Struct 
{
 
    private $data;
    private $definition;
    private $_aliases = array();    
 
    function __construct(array $definition) {
        $this->definition = $definition;
        $this->alias();
    }
 
    function __get($name) {
        return $this->data[$name];
    }
 
    function __set($name, $value) 
    {   
        if (isset($this->definition[$name]))
        {
            $value_type = gettype($value);
            $definition_type = $this->definition[$name];
        
            // alias
            foreach ((array) $this->_aliases as $alias => $typo)
                if ($definition_type==$alias) $definition_type=$typo;
                        
            if (($value_type === $definition_type) || $value instanceof $definition_type)
                $this->data[$name] = $value;
                
            else
                throw new Exception("Trying to assign ({$definition_type}: {$name}) with {$value_type}");
        }else
            throw new Exception("Trying to access undefined variable {$name}");
            
    }       
    
    /* setter on-off */
    function alias($flag=true)
    {
        $this->_aliases= $flag ? array('bool'=>'boolean','int'=>'integer','float'=>'double','str'=>'string') : null;
            
        return $this;   
    }   
}
 

Código PHP:

class Persona extends Struct {
 
    function __construct() {
        parent::__construct([
            'nombre'           => 'str',
            'apellidos'        => 'str',
            'hijos'            => 'int',
            'fecha_nacimiento' => 'DateTime',
            'telefonos'        => 'array'
        ]);
    }
 
}
 
$p = new Persona;
 
$p->nombre = 'Pablo';
$p->apellidos = 'Bozzolo';
$p->fecha_nacimiento = new DateTime('1980-10-01');
$p->telefonos = ['435435435', '342343242'];
 
debug($p);
 

[lolainas]

Muy bueno

[hhs]

Excelente conclusión en la implementación para los dos.

[Italico76]

Gracias compa, Ud sabe que tomo muchos de sus sugerencias y valioso conocimiento

Aprovecho para felicitar a @lolainas y @NSD por sus aportes en este y otros hilos

[lolainas]

Felicitaciones para ti que aportas retos e ideas interesantes.

Y felicitaciones a hhs q me entretiene y me gusta leer sus respuestas sobre temas de diseño.

Saludos.