design-nation.blog/es: Febrero 2004 Archivos

Estructuras de datos: tabla hash

Una tabla hash es una especie de colecciÛn de listas enlazadas. Nos permite guardar pares clave-valor, y luego recuperar esos datos utilizando la clave.

Encontrar·s una definiciÛn mejor aquÌ

Y mi implementaciÛn aquÌ

Para testearlo puedes utilizar algo como esto:


import net.designnation.structs.*


var a: HashMap= new HashMap( );

// Setitem
//
key= "4";
trace( "Agrego "+ key );
a.setItem( key, new Object( key ) );
trace( "Contenidos del HashMap: "+ a.toString(  ) );

key= "21";
trace( "Agrego "+ key );
a.setItem( key, [ "a1", "a2" ] );
trace( "Contenidos del HashMap: "+ a.toString(  ) );

key= "5";
trace( "Agrego "+ key );
a.setItem( key, new Object( key ) );
trace( "Contenidos del HashMap: "+ a.toString(  ) );

key= "8";
trace( "Agrego "+ key );
a.setItem( key, new Object( key ) );
trace( "Contenidos del HashMap: "+ a.toString(  ) );

key= "81";
trace( "Agrego "+ key );
a.setItem( key, new Object( key ) );
trace( "Contenidos del HashMap: "+ a.toString(  ) );

key= "8";
trace( "Agrego "+ key );
a.setItem( key, new Object( key ) );


trace( "Contenidos del HashMap: "+ a.toString(  ) );
// GetItem
//
key= "8";
trace( "Tomo el valor de "+ key );
trace( a.getItem( key ).toString(  ) );
// Count
//
trace( "TamaÒo: "+ a.count(  ) );

// Remove
//
key= "4";
trace( "Elimino "+ key );
a.remove( key );
trace( "Contenidos del HashMap: "+ a.toString(  ) );
trace( "TamaÒo: "+ a.count(  ) );

key= "4";
trace( "Elimino "+ key );
a.remove( key );
trace( "Contenidos del HashMap: "+ a.toString(  ) );
trace( "TamaÒo: "+ a.count(  ) );

Publicado por Cesar Tardaguila a las 12:47 AM | Enlace permanente | Comentarios (5) | TrackBacks (0)

Accediendo a las propiedades de una clase de forma din·mica

Es probable que esto no suponga niguna novedad, pero de todas formas, vamos all·:

Actualmente estoy trabajando en una clase para serializar y deserializar otras clases. Por ejemplo, la siguiente:


class net.designnation.tests.Serializable
{
	private var prop1: String;
	private var prop2: Number;
	private var prop3: Object;
	
	private var unseen: String;
	
	public static var CONSTANT: String = "Esto es una constante";
	
	function Serializable( )
	{	
		this.unseen = "Hola, mundo!";
	}
	
	public function set val1( param: String )
	{
		this.prop1 = param + " <:::::::: setter ";
	}
	
	public function get val1( ): String
	{
		return this.prop1 + " <:::::::: getter ";;
	}
	
	public function set val2( param: Number )
	{
		this.prop2 = param + 100;
	}
	
	public function get val2( ): Number
	{
		return this.prop2 + 10000;
	}
	
	public function set val3( param: Object )
	{
		this.prop3 = param;
	}
	
	public function get val3( ): Object
	{
		return this.prop3;
	}
}

Para leer sus propiedades, podemos hacer lo siguiente:


import net.designnation.tests.*
import net.designnation.utils.*

var myClass: Serializable = new Serializable( );

myClass.val1 = "Hi!";
myClass.val2 = 32;
myClass.val3 = { prop: "value" };

trace(" ------------------------\n ");
for ( var k in myClass )
{
	trace( k + " == " + myClass[ k ] );
}

//setting

for ( var k in myClass )
{
	if ( k == "prop1" ) myClass[ k ] = "modificado";
	if ( k == "unseen" ) myClass[ k ] = "unseen, modificado";
}
//checking

trace(" \n------------------------\n ");
for ( var k in myClass )
{
	trace( k + " == " + myClass[ k ] );
}

Pero, quÈ ocurre cuando queremos acceder a esas propiedades a travÈs de sus getters / setters?. Pues que no lo podemos hacer, ya que no aparecen en el bucle for .. in

Pero, utilizando ASSetPropFlags, se pueden mostrar todas las propiedades y mÈtodos de myClass.__proto__, es decir, de la clase a partir de la cual se instancia ese objeto. Esto es muy peligroso, porque realmente no se sabe durante cu·nto tiempo va a seguir existiendo ese mÈtodo. Pero, para nuestro caso, es la forma de poder acceder a todos los mÈtodos de la clase


class net.designnation.utils.showProps
{
	static function showAll( obj )
	{
		_global.ASSetPropFlags( obj.__proto__, null, 0, 1 );
		return obj;
	}
}

De vuelta al script:


// Mostrando todas las propiedades

myClass = showProps.showAll( myClass );

trace(" \n------------------------\n ");
for (var k in myClass)
{
	trace( k );
}

//Obeteniendo los valores a travÈs de los getters

trace( " \n------------------------\n " );
trace( " Llamando a los getters \n" );
for (var k in myClass)
{
	var prefix: String = k.substring( 0, 7 );
	var posfix: String = k.substring( 7, k.length);
	
	if ( prefix == "__get__" )
	{
		trace( myClass[ k ]( ) );
	}
}

trace( " \n------------------------\n " );
trace( " seteando utilizando los setters \n" );
for (var k in myClass)
{
	var prefix: String = k.substring( 0, 7 );
	var posfix: String = k.substring( 7, k.length);
	
	if ( prefix == "__set__" )
	{
		if ( posfix == "val1" ) myClass[ k ]( " the end " );
	}
}

trace( myClass.val1 );

Resuelto. Peligroso, no muy limpio, pero puede sacar de alg˙n apuro.

Publicado por Cesar Tardaguila a las 10:45 PM | Enlace permanente | Comentarios (0) | TrackBacks (0)

Lista enlazada V2

La semana pasada publicamos una clase para implementar listas enlazadas. Bueno, pues ahora esa clase ha sido mejorada y limpiada, para hacerla m·s eficaz.

No cambia nada en la forma de implementarla, excepto el mÈtodo "insert" que ahora se llama "insertOrdered".

Descarga las clases necesarias aquÌ.

Publicado por Cesar Tardaguila a las 07:19 AM | Enlace permanente | Comentarios (0) | TrackBacks (0)

ImplementaciÛn de una lista enlazada

Pues vamos con una implementaciÛn de una lista enlazada simple. El cÛdigo necesita ser optimizado (sobre todo porque el mÈtodo deleteElement se apoya en otro que hace pr·cticamente lo mismo, y porque la lista se recorre por Ìndices, y podrÌa hacerse mejor simplemente mirando a los punteros). Pero sirve para empezar. De todas formas, seg˙n vaya oiptimizando el cÛdigo, irÈ posteando las novedades.

øCÛmo funciona?. Pues para crear una instancia de la lista, se le pasa como par·metro una instancia de una clase llamada "comparador", que tiene definido un mÈtodo lessThan() que es el que se encarga de decidir cÛmo se debe ordenar la lista. En este caso, la lista va a contener objetos, y la ordenaciÛn ser· por la propiedad "index" de esos objetos (ordenaciÛn ascendente, por cierto).

Por tanto, esa clase comparador quedarÌa m·s o menos asÌ:


class net.designnation.structs.Comparador implements IOrder
{

	function Comparador()
	{
	
	}
	
	public function lessThan( firstComp: Object, secondComp: Object): Boolean
	{
		if (firstComp.index< secondComp.index)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
}

Entonces, para crear la lista harÌamos:


import net.designnation.structs.*;

var myList:List = new List(new Comparador());

Y para manipularla:


myList.push({index:6, prop:"propvalue6"});
myList.insert({index:3, prop:"propvalue3"});

trace("Lista " + myList);

myList.insert({index:0, prop:"propvalue0"});
trace("Lista " + myList);

myList.insert({index:2, prop:"propvalue2"});
trace("Lista " + myList);

myList.insert({index:1, prop:"propvalue1"});
trace("Lista " + myList);

myList.insert({index:4, prop:"propvalue4"});
trace("Lista " + myList);

myList.insert({index:5, prop:"propvalue5"});
trace("Lista " + myList);

myList.insert({index:7, prop:"propvalue7"});
trace("Lista " + myList);

myList.insert({index:6, uno:"propvalue6"});
trace("Lista " + myList);

Si te resulta de interÈs, puedes descargarte el cÛdigo aquÌ

Publicado por Cesar Tardaguila a las 01:29 PM | Enlace permanente | Comentarios (4) | TrackBacks (0)

design-nation.blog/es

Febrero 17, 2004

Estructuras de datos: tabla hash

Febrero 11, 2004

Accediendo a las propiedades de una clase de forma din·mica

Febrero 09, 2004

Lista enlazada V2

Febrero 01, 2004

ImplementaciÛn de una lista enlazada