19 abr 2011

AS3 Patterns – Iterator

Na programação orientada a objetos um iterador é um objeto que possibilita o programador a examinar um objeto que contem outros objetos (container).

As semânticas de acesso dos iteradores são fixas e você pode implementar diversos tipos de iteradores de forma desacoplada a partir de uma interface.
Imagine um iterador como um cursor de uma base de dados onde os elementos são acessados sequencialmente (cursor).

Os arquivos utilizados podem ser encontrados em:
https://github.com/wlepinski/as3-patterns/tree/master/Iterator

Basicamente a interface de um iterador pode ser definida como:

1
2
3
4
5
6
7
8
public interface IIterator
{
    function first ():void;
    function next ():void;
    function isDone ():Boolean;
    function currentItem ():*;
    function hasNext():Boolean;
}

Com essa interface podemos prover algumas implementações de iteradores para qualquer tipo de objeto que descreva qual o seu iterador, a interface abaixo será utilizada pelos nosso objetos que podem ser iterados.

1
2
3
4
5
6
7
public interface IAbstractList
{
    function createIterator ():IIterator;
    function count ():int;
    function append ( item:Object ):void;
    function remove ( item:Object ):void;
}

Vamos criar um iterador (ArrayIterator) que implementa a interface IIterator e recebe como parâmetro no construtor um ArrayList que também vamos implementar a seguir:

Implementação do ArrayIterator:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public class ArrayIterator implements IIterator
{
    public var index:int = 0;
    public var list:ArrayList;

    public function ArrayIterator ( list:ArrayList ) {
        this.list = list;
    }

    public function first ():void {
        index = 0;
    }

    public function next ():void {
        index++;
    }

    public function isDone ():Boolean {
        return index >= list.count();
    }

    public function currentItem ():* {
        return list.array[ index ];
    }

    public function hasNext ():Boolean {
        return index < list.count();
    }
}

Implementação do ArrayList:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public class ArrayList implements IAbstractList
{
    public var array:ArrayCollection = new ArrayCollection();

    public function ArrayList (){
    }

    public function createIterator ():IIterator
    {
        return new ArrayIterator( this );
    }

    public function count ():int
    {
        return array.length;
    }

    public function append ( item:Object ):void
    {
        array.addItem( item );
    }

    public function remove ( item:Object ):void
    {
        array.removeItemAt( array.getItemIndex( item ) );
    }
}

Podemos utilizar o iterador de duas formas, em um “for” ou em um “while”:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
var list:IAbstractList;
var iterator:IIterator;

// Utilizando o for
list = new ArrayList();
list.append( "Array Item 1" );
list.append( "Array Item 2" );
list.append( "Array Item 3" );

iterator = list.createIterator();

for ( iterator.first(); !iterator.isDone(); iterator.next() )
{
    trace( iterator.currentItem() );
}

// Usando while
list = new ArrayList();
list.append( "Array2 Item 1" );
list.append( "Array2 Item 2" );
list.append( "Array2 Item 3" );

iterator = list.createIterator();

while ( iterator.hasNext() ){
    trace( iterator.currentItem() );
    iterator.next();
}

Leave a Comment