Somms.NET » Blog » Tipos Enumerados en AS3(II)
<
>

Tipos Enumerados en AS3(II)

12 de Diciembre de 2008

Siguiendo con el artículo Tipos Enumerados en AS3, vamos a dar una solución correcta al problema de la herencia desde nuestra nueva clase Enum.

Como vimos, es necesario bloquear la creación de las clases mediante un bloque estático después de que se definan las constantes de nuestro enumerado. Dado que el bloqueo se realiza desde el constructor de Enum hay que utilizar un sistema que nos permita bloquear selectivamente las clases hijas según su tipo. Para esto podemos utilizar una lista, en la que iremos agregando los tipos de clases bloqueadas, y en el constructor de Enum verificamos su existencia. Así Enum tendría el siguiente código:

  1. package net.somms.utils
  2. {
  3.         import de.polygonal.ds.Set;
  4.        
  5.         import flash.utils.getQualifiedClassName;
  6.        
  7.         public class Enum
  8.         {
  9.                 protected var value:String;
  10.                 static private var lockList:Set=new Set();
  11.                 /**
  12.                  * Bloquea la instanciacion de clases
  13.                  * @param target Nombre "cualificado" de la clase: namespace::clase
  14.                  */                    
  15.                 protected static function lock(target:String):void
  16.                 {
  17.                        
  18.                         if(!lockList.contains(target))
  19.                         {
  20.                                 lockList.set(target);
  21.                         }
  22.                         else
  23.                         {
  24.                                 throw new Error("El objeto " + target + " ya ha sido bloquedao");
  25.                         }
  26.                        
  27.                        
  28.                 }
  29.                 /**
  30.                  * Verifica si una clase esta bloqueada
  31.                  * @param target Nombre "cualificado" de la clase: namespace::clase
  32.                  * @return Si esta o no bloqueado.
  33.                  *
  34.                  */            
  35.                 private static function isLocked(target:String):Boolean
  36.                 {
  37.                         return lockList.contains(target);
  38.                 }
  39.                
  40.                 public function Enum(Value:String)
  41.                 {
  42.                         if(!isLocked(getQualifiedClassName(this)))
  43.                         {
  44.                                 this.value = Value;            
  45.                         }
  46.                         else
  47.                         {
  48.                                 throw new Error("No se pueden crear instancias de " + getQualifiedClassName(this));
  49.                         }
  50.                 }
  51.                
  52.                 public function toString():String
  53.                 {
  54.                        
  55.                         return value;
  56.                 }
  57.                
  58.                
  59.         }
  60. }

El método lock será llamado desde las clases hijas para bloquear la construcción de una clase. Lo que hace es agregar el nombre de la clase a lockList. Después en el constructor de Enum se llama a isLocked, y en caso de que sea afirmativo lanza un error en tiempo de ejecución.

En las clases que hereden habrá que incluir el bloque de código estático que llama al bloqueo. Por ejemplo:

  1. package net.somms.i8n
  2. {
  3.         import flash.utils.getQualifiedClassName;
  4.        
  5.         import net.somms.utils.Enum;
  6.        
  7.                
  8.         public final class IdiomEnum extends Enum
  9.         {
  10.                 public static const English:IdiomEnum = new IdiomEnum("EN");
  11.                 public static const Spanish:IdiomEnum = new IdiomEnum("");
  12.                 {
  13.                         lock("net.somms.utils::IdiomEnum");
  14.                         //trace("Codigo estático de IdiomEnum " + lock);
  15.                 }
  16.                 public function IdiomEnum(Name:String)
  17.                 {
  18.                         //trace("Constructor de IdiomEnum");
  19.                         super(Name);
  20.                        
  21.                 }
  22.  
  23.         }
  24. }

Como se vé, hacemos una llamada a lock pasando como parámetro el nombre “cualificado” de la clase. De esta manera la clase no se podrá crear más.

Categorías: Actionscript 3, Flash, Flex, Informática, Programación
Comentarios: RSS 2.0.
Puedes dejar una respuesta, o un enlace de seguimiento desde tu propio sitio web.

Deja Una Respuesta

  • qrcode link

Ir al sitio para móviles