Pedro Teixeira » Tecnologia

Design Patterns using Action Script 3: Structural Patterns (Decorator & Adapter & Composite)

Pedro — Mon, 08 Mar 2010 20:48:49 +0000

Decorator

Example related in book, that shows use of Decorator Pattern. It´s used when necessary to choose many properties dynamically like the sum of shopping cart products.

File Component.as:

Code block

package
{
    //Abstract Component in Decorator Design Pattern
    //**************
    //Abstract class
    public class Component
    {
    	internal var information:String;
        public function getInformation():String
	{
	    return information;
	}
    }
}

File Decorator.as:

Code block

package
{
    //Abstract Decorator in Decorator Design Pattern
    //**************
    //Abstract class
    public class Decorator extends Component
    {
	trace("|*|Decorator|*|");
	override public function getInformation():String
	{
            return information;
	}
    }
}

File ConcreteComponent.as:

Code block

package
{
    //Concrete Component
    public class ConcreteComponent extends Component
    {
	public function ConcreteComponent():void
	{
            //\u2794 is Unicode for a right-pointing arrow
	    information = "Concete Component is decorated with \u2794";
	}
    }
}

File DecConA.as:

Code block

package
{
    //Concrete Decorator "Alpha"
    public class DecConA extends Decorator
    {
	var components:Component;
	public function DecConA(components:Component)
	{
	    this.components=components;
	}
	override public function getInformation():String
	{
	    return components.getInformation() + " Decoration Alpha:";
	}
    }
}

File DecConB.as:

Code block

package
{
    //Concrete Decorator "Beta"
    public class DecConB extends Decorator
    {
	var components:Component;
	public function DecConB(components:Component):void
	{
	    this.components=components;
	}
	override public function getInformation():String
	{
	    return components.getInformation() + " Decoration Beta:";
	}
    }
}

File DecTest.as:

Code block

package
{
    import flash.display.Sprite;
    public class DecTest extends Sprite
    {
	public function DecTest():void
	{
	    //Instantiate Concrete Component
	    var testComponent:Component = new ConcreteComponent();
	    //Wrap first decorator around component
	    testComponent=new DecConA(testComponent);
	    //Wrap second decorator around component
	    testComponent=new DecConB(testComponent);
	    //Output results
	    trace(testComponent.getInformation());
	}
    }
}

Adapter

Example related in book, that shows use of Adapter Pattern. This pattern allows existing classes to be used in situations that didn´t exist or weren´t anticipated when they were developed.

File Adaptee.as:

Code block

package {
 
    public class Adaptee {
 
	public function specificRequest():void {
	    trace("Called Adaptee:specificRequest()");
	}
    }
}

File Itarget.as:

Code block

package {
 
    public interface ITarget {
	function request():void
	function newOperation():void
    }
}

File Adapter.as:

Code block

package {
 
    public class Adapter implements ITarget {
 
	private var adaptee:Adaptee;
 
	public function Adapter() { // constructor
	    this.adaptee = new Adaptee();
	}
 
	public function request():void {
	    adaptee.specificRequest();
	}
 
	public function newOperation():void {
	    trace("Called Adapter:newOperation()");
	}
    }
}

File Main.as:

Code block

package {
 
    import flash.display.MovieClip;
 
    /**
     *	Main Class
     *	@ purpose: Document class for movie
     */
    public class Main extends MovieClip {
 
	public function Main() {
 
	    var target:ITarget = new Adapter();
 
	    target.request();
	    target.newOperation();
	}
    }
}

Composite

Example related in book, that shows use of Composite Pattern. The Composite Pattern provides a robust solution to building complex systems that are made up of several smaller components.

File Component.as:

Code block

package {
 
    import flash.errors.IllegalOperationError;
 
    // ABSTRACT Class (should be subclassed and not instantiated)
    public class Component {
 
	protected var parentNode:Composite = null;
 
	public function add(c:Component):void {
	    throw new IllegalOperationError("add operation not supported");
	}
 
	public function remove(c:Component):void {
	    throw new IllegalOperationError("remove operation not supported");
	}
 
	public function getChild(n:int):Component {
	    throw new IllegalOperationError("getChild operation not supported");
	    return null;
	}
 
	// ABSTRACT Method (must be overridden in a subclass)
	public function operation():void {
	}
 
	public function getParent():Composite {
	    return this.parentNode;
	}
 
	internal function setParent(compositeNode:Composite):void {
	    this.parentNode = compositeNode;
	}
 
	internal function removeParentRef():void {
	    this.parentNode = null;
	}
 
	internal function getComposite():Composite {
	    return null;
	}
 
    }
}

File Composite.as:

Code block

package {
 
    public class Composite extends Component {
 
	protected var sName:String;
	protected var aChildren:Array;
 
	public function Composite(sName:String) {
	    this.sName = sName;
	    this.aChildren = new Array();
	}
 
	override public function add(c:Component):void {
	    aChildren.push(c);
	    c.setParent(this);
	}
 
	override public function operation():void {
	    trace(this.sName);
	    for each (var c:Component in aChildren) {
		c.operation();
	    }
	}
 
	override public function getChild(n:int):Component {
	    if ((n > 0) && (n <= aChildren.length)) {
		return aChildren[n-1];
	    } else {
		return null;
	    }
	}
 
	override internal function getComposite():Composite {
	    return this;
	}
 
	private function safeRemove(c:Component) {
	    if (c.getComposite()) {
		c.remove(c); // composite
	    } else {
		c.removeParentRef();
	    }
	}
 
	override public function remove(c:Component):void {
	    if (c === this) {
		// remove all my children
		for (var i:int = 0; i < aChildren.length; i++) {
		    safeRemove(aChildren[i]); // remove children
		}
		this.aChildren = []; // remove references to children
		this.removeParentRef(); // remove my parent reference
	    } else {
		for (var j:int = 0; j < aChildren.length; j++) {
		    if (aChildren[j] == c) {
			safeRemove(aChildren[j]); // remove child
			aChildren.splice(j, 1); // remove reference
		    }
		}
	    }
	}
    }
}

File Leaf.as:

Code block

package {
 
    public class Leaf extends Component {
 
	private var sName:String;
 
	public function Leaf(sName:String) {
	    this.sName = sName;
	}
 
	override public function operation():void {
	    trace(this.sName);
	}
    }
}

File Main.as:

Code block

package {
 
    import flash.display.MovieClip;
 
    /**
     *	Main Class
     *	@ purpose:		Document class for movie
     */
    public class Main extends MovieClip {
 
	public function Main() {
 
	// create root node
	var root:Composite = new Composite("root");  
 
	// add a node to root
	root.add(new Composite("composite 1")); // add node to root as child
	root.getChild(1).add(new Leaf("leaf 1")); // add a child leaf
	root.getChild(1).add(new Leaf("leaf 2")); // add a child leaf
 
	// add another node
	root.add(new Composite("composite 2")); // add node to root as child
	root.getChild(2).add(new Leaf("leaf 3")); // add a child leaf
	root.getChild(2).add(new Leaf("leaf 4")); // add a child leaf
	root.getChild(2).add(new Leaf("leaf 5")); // add a child leaf
 
	// add a child leaf to the root node
	root.add(new Leaf("leaf 6"));
 
	trace("display tree");
	trace("============");
	root.operation(); 
 
	trace("remove first child of the second child of root");
	trace("==============================================");
	root.getChild(2).remove(root.getChild(2).getChild(1));
	root.operation();
 
	trace("remove the second child of root");
	trace("===============================");
	root.remove(root.getChild(2));
	root.operation();
	}
    }
}

Design Patterns using Action Script 3: Creational Patterns (Factory & Singleton)

Pedro — Thu, 04 Mar 2010 15:16:29 +0000

I´m reading the O´Reilly book “ActionScript 3.0 Design Patterns”. Following are examples related in this excellent book but modified by me. This is the first part, about creational patterns (Singleton and Factory).

Singleton

Class User.as, used to store user proprieties.

Code block

package classes
{
    public const User:_Singleton = new _Singleton();
}
 
/**
 * Class Singleton with proprieties to use in application
 */
internal class _Singleton
{
    function _Singleton(){}
 
    public var id:int;
    public var name:String;
    public var description:String;
    public var username:String;
    public var password:String;
}

Factory

Example related in book, that shows creation of products.

File Creator.as:

Code block

package example {
 
    import flash.errors.IllegalOperationError;
 
    // ABSTRACT Class (should be subclassed and not instantiated)
    public class Creator {
 
    	public function doStuff():void {
    	    var product:IProduct = this.factoryMethod();
	    product.manipulate();
        }
 
	// ABSTRACT Method (must be overridden in a subclass)
	protected function factoryMethod():IProduct {
            throw new IllegalOperationError("Abstract method: must be overridden in a subclass");
	    return null;
	}
    }
}

File CreatorA.as:

Code block

package example {
 
    // Concrete creator A (subclass of Creator)
    public class CreatorA extends Creator {
 
        override protected function factoryMethod():IProduct {
            trace("Creating product 1");
	    return new Product1(); // returns concrete product
        }
    }
}

File CreatorB.as:

Code block

package example {
 
    // Concrete creator B (subclass of Creator)
    public class CreatorB extends Creator {
 
        override protected function factoryMethod():IProduct {
            trace("Creating product 2");
	    return new Product2(); // returns concrete product
        }
    }
}

File IProduct.as:

Code block

package example {
 
    public interface IProduct {
        function manipulate():void;
    }
}

File Product1.as:

Code block

package example {
 
    internal class Product1 implements IProduct {
 
        public function manipulate():void {
	    trace("Doing stuff with Product1");
        }
    }
}

File Product2.as:

Code block

package example {
 
    internal class Product2 implements IProduct {
 
        public function manipulate():void {
	    trace("Doing stuff with Product2");
        }
    }
}

package classes
{
public const User:_Singleton = new _Singleton();
}

/**
* Class Singleton that represents proprieties used to change language
*/
internal class _Singleton
{
function _Singleton(){}

public var id:int;
public var name:String;
public var description:String;
public var username:String;
public var password:String;

}

Google Translate com pronúncia em inglês

Pedro — Wed, 18 Nov 2009 00:23:47 +0000

Hoje dei de caras com um novo design do iGoogle. Embora tenham mudado muito pouco nota-se um esforço de uniformização dos serviços por parte da empresa. O que não estava à espera é que redesenhassem também um dos serviços que mais procurado é pelo utilizador, o Google Translate.

Entre as mudanças destaca-se um “pronunciador”, que nesta fase apenas está disponível em inglês. Todos os textos que sejam traduzidos de qualquer língua para inglês podem agora ser ouvidos.

Para além disso também foi introduzida a tradução instantânea, isto é, a tradução vais sendo feita à medida que escrevemos o texto.

Fileinspect – Processos do Windows

Pedro — Fri, 23 Oct 2009 14:52:12 +0000

Todos os utilizadores, sejam eles vulgares ou técnicos, deparam-se com mensagens do Windows sobre determinado processo. Por vezes é necessário saber ao certo o que um determinado processo faz ou a causa de um erro qualquer.

Nesse sentido, File Inspect Library disponibiliza uma base de dados bastante extensa e detalhada sobre cada processo do Windows, para além da indicação de possíveis causa de erro e indicações sobre como os resolver.

Google Translate: Tradução de documentos

Pedro — Thu, 16 Jul 2009 13:44:01 +0000

O Google Translate já consegue traduzir documentos:

É só clicar em “Carregar documento”, fazer upload do ficheiro e voilá.

20 ferramentas para programadores

Pedro — Thu, 16 Jul 2009 13:26:26 +0000

Existem inúmeras ferramentas na internet que fazem aumentar a produtividade dos designers, programadores e até utilizadores em geral. Algumas dessas ferramentas são extremamente úteis, outras uma perda de tempo. No entanto nem todas são freeware, por isso deixo aqui uma lista de 20 ferramentas desse tipo.

Dropbox – Partilha de ficheiros online

FreshBooks – Serviços de facturação

OpenWith – Programas para tipos de ficheiros

SiWapp – Sistema de facturação

Tracer – Monitorização de sites

Adobe Kuler – Gerador de cores / fontes

TypeTester – Comparador de estilos / cores

ShowDocument – Visualização de documentos partilhados

Wix – Web IDE Flash

HTML->PDF Converter – Conversor HTML -> PDF

OldVersion – Download de anteriores versões de programas

Firebug - Plugin de firefox para WebDevelopers

What The Font – Identificador de fontes

SplashUp – Editor de imagem online

Test Everything – Validador de sites

FormatPixel – Design de brochuras e cartazes online

Browser Shots – Screenshots de um site em vários browsers

Answer IM – Mensageiro

FileMail - Enviar ficheiros de grande tamanho via email

SpringLoops – Serviços de colaboração

Fonte

Mapa mundial das redes sociais

Pedro — Sun, 14 Jun 2009 10:28:25 +0000

Enquanto navegava pela internet, dei de caras com o mapa mundial das redes sociais, que retrata qual a rede dominante em cada país:

(Clicar para aumentar a imagem)

Como se pode observar, o Facebook domina claramente em todo o mundo. Curiosidade, ou talvez não, o Hi5 surge em primeiro lugar em Portugal, acompanhado pela Colômbia e Roménia.

Fonte

Revista PROGRAMAR nº20 – Junho

Pedro — Fri, 12 Jun 2009 23:23:48 +0000

Saiu a 20ª edição desta revista nacional de programação.

Nesta edição destaca-seum artigo que explora o tema da metaprogramação e templates em C++, as continuações dos artigos acerca da linguagem AWK e do Google Web Toolkit, um novo artigo sobre o Arduino e uma breve apresentação do projecto DEI@Academy

Download