LAlex devblog v6 - AS2

Proxy et Interval

-Alexandre LEGOUT aka LAlex- — Tue, 22 Aug 2006 14:02:00 +0200

Pas grand chose de neuf en ce moment, je passe beaucoup de temps en maintenance de code. Du coup, je vous propose deux petites classes qui me servent énormément au quotidien. Chaque développeur qui passe ses journées dessus doit avoir un équivalent je suppose: une classe de proxy, héritière du fameux Delegate, et une classe Interval, qui m'évite la permanente prise de tête avec les ids des setInterval...

import com.lalex.core.CoreObject;



/**

 * @author LAlex

 * @class com.lalex.utils.Proxy

 */



class com.lalex.utils.Proxy

        extends CoreObject {

                

        public static function createFunction(o, f:Function):Function {

                return create.apply(null, arguments).getProxyFunction();

        }

                

        public static function create(o, f:Function):Proxy {

                var px:Proxy = new Proxy(o, f);

                var args:Array = arguments;

                args.splice(0,2);

                px.setArguments(args);

                return px;

        }

        

        private var _scope;

        private var _fct:Function;

        

        private var _proxy:Function;



        private var _args : Array;

        

        function Proxy(o, f:Function) {

                _scope = o;

                _fct = f;

                setArguments(arguments.slice(2));

                createProxyFunction();

        }

        

        private function createProxyFunction() {

                _proxy = function() {

                        var ff = arguments.callee.f;

                        var fs = arguments.callee.s;

                        var fa = arguments.callee.a;

                        ff.apply(fs, arguments.concat(fa));

                };

                _proxy.f = _fct;

                _proxy.s = _scope;

                _proxy.a = _args;

        }

        

        public function getProxyFunction():Function {

                return _proxy;

        }

        

        public function getFunction():Function {

                return _fct;

        }

        

        public function setArguments(a : Array) {

                _args = a.concat();

                if (_proxy) {

                        _proxy.a = _args;

                }

        }

        

        public function getScope():Function {

                return _scope;

        }

        

        public function equals(p:Proxy):Boolean {

                if (p.getScope() == _scope && p.getFunction() == _fct) {

                        return true;

                }

                return false;

        }

        

        public function launch() {

                _proxy.apply(null, arguments);

        }

        

}

import com.lalex.utils.Proxy;



/**

 * @author LAlex

 * @class com.lalex.utils.Interval

 */

class com.lalex.utils.Interval {

        

        private var _itv:Number = -1;

        private var _px:Proxy;

        

        private var _tim:Number;

        

        private var _nb:Number = 0;

        private var _max:Number = Number.POSITIVE_INFINITY;

        

        function Interval(tgt:Object, fct:Function, tim:Number, max:Number) {

                _px = new Proxy(tgt, fct);

                setTime(tim);

                setMax(max);

        }

        

        function setMax( max : Number ) {

                _max = max ? max : Number.POSITIVE_INFINITY;

        }

        

        function start( launchNow : Boolean ) : Void {

                

                stop();

                

                resume(launchNow);



        }

        

        function resume( launchNow : Boolean ) {

                if (!isRunning()) {

                        if (launchNow) {

                                launchProxy();

                        }

                        _itv = setInterval(this, "launchProxy", _tim);

                }

        }

        

        private function launchProxy() {

                if (_nb++ < _max) {

                        _px.launch();

                } else {

                        stop();

                }

        } 

        

        public function isRunning() : Boolean {

                return _itv != -1;

        }

        

        function setTime( time : Number ) : Void {

                pause();

                _tim = time;

        }

        

        public function pause() {

                if (isRunning()) {

                        clearInterval(_itv);

                        _itv = -1;

                }

        }

        

        public function stop() {

                pause();

                _nb = 0;

        }

        

}

Number = parseInt

-Alexandre LEGOUT aka LAlex- — Fri, 09 Jun 2006 18:49:58 +0000

Number, en plus d'être une classe, est également une fonction, tout comme le sont Array, Boolean et String. Elle permet de convertir un objet quelconque en une instance de Number.

Seulement, ce qui n'est pas précisé dans la doc, c'est que cette fonction suit les mêmes règles que parseInt, sans pouvoir toutefois lui passer de second paramètre, qui précise dans quelle base doit se faire la conversion. Ce qui signifie que :

Les chaines de caractères commencant par "0x" seront considérées comme héxadécimales
Les chaines de caractères commencant par "0" seront considérées comme octales.

Et c'est sur ce dernier point que je me suis fait avoir, en cherchant un long moment pourquoi mon "062" devenait 50... :\ J'ai donc du remplacer toutes mes conversions :var num:Number = Number("062") // num = 50 // par var num:Number = parseInt("062", 10) // num = 62

Donc voilà, si ca peut profiter à quelqu'un..

Constructeur et arguments

-Alexandre LEGOUT aka LAlex- — Wed, 10 May 2006 15:06:32 +0000

Lors qu'une classe hérite d'une autre, tout l'interêt est bien évidemment de ne pas réimplémenter les methodes de la classe mère. En effet, en l'absence d'une méthode portant le nom demandé, la méthode de la classe mère est appelée, transmettant ainsi tous les arguments. Eh bien ce qui est dommage, c'est que ce n'est pas le cas du constructeur... :\

En effet, si une classe mère prend un argument en paramètre, et qu'une classe fille hérite de cette dernière sans implémenter de constructeur, les paramètres passés au constructeur de la classe fille ne seront pas transmis.

La preuve par l'exemple: j'utilise actuellement un ensemble de managers gérant chacun des objets (Contacts, Articles, etc...) dont les classes implémentent toutes la même interface. Le but est donc de créer un manager "de base" (non instanciable) qui factorise les comportements communs... Chaque manager est lié à un contexte dans l'application, qui est passé en paramètre au constructeur du manager:
/* == Classes utilisées interface Item class Contact implements Item class Context */ // Classe mère class BaseManager { private var _context:Context; private var _selectedItem:Item; // Le constructeur prend un paramètre private function BaseManager(ctx : Context) { _context = ctx; } public function getContext() : Context { return _context; } public function getSelectedItem() : Item { return _selectedItem; } private /*protected*/ function setSelectedItem(i : Item) { if (i != _selectedItem) { _selectedItem = i; dispatchEvent({type:"selectionChanged", selected:_selectedItem}); } } } class ContactManager extends BaseManager { // Force le typage à 'Contact' private function setSelectedItem(c : Contact) { super.setSelectedItem(c); } public function getSelectedContact() : Contact { return Contact(getSelectedItem()); } } // Création du contexte var ctx:Context = new Context("mainApp"); // Création du ContactManager var contactManager:ContactManager = new ContactManager(ctx); // Affichage du contexte trace(contactManager.getContext()); // undefined Ceci est trés certainement du à la conversion en AS1. En effet, en AS1, déclarer une classe revient à déclarer son constructeur, et donc a relayer "manuellement" les paramètres du constructeur si besoin. Le "compilo" AS2 du coup crée automatiquement un constructeur dont le code est:function ContactManager() { super(); } alors que dans mon cas, il faut que je crée le constructeur moi-même:function ContactManager(c : Context) { super(c); }
C'est peut-être déjà connu de beaucoup, mais moi j'ai cherché un p'tit moment quand-même... Bref, cela revient encore et toujours au problème d'appeler le constructeur d'une classe mère avec un nombre indéfini d'arguments (l'idéal étant avec apply)... :\

Switch/case original : tester la classe d'une variable

-Alexandre LEGOUT aka LAlex- — Wed, 15 Feb 2006 14:19:53 +0000

Pour ceux qui ne lisent pas la mailing-list de OSFlash, Ralf Bokelberg y donne une petite astuce pour tester la classe d'une variable, et de manière plus globale comment éviter une succession de if...else if...else.

En fait, le switch...case a pour limitation de ne servir qu'à comparer une valeur à une autre (ou plusieurs autres), alors qu'un if va vérifier si une condition est vraie. Mais, et c'est là qu'est l'astuce, vérifier si une condition est vraie consiste uniquement à comparer son résultat à true... et voila! Petit exemple:public static function getEnvironement(eng : Engine) : String { var env:String = "Twilight zone"; switch(true) { case (eng instanceof Boat): env = "Water"; break; case (eng instanceof Car): case (eng instanceof Motorcycle): case (eng instanceof Bus): env = "Road"; break; case (eng instanceof Plane): env = "Sky"; break; case (eng instanceof Spacecraft): env = "Outerspace"; break; default: trace("ET???"); } return env; }

C'est peut-être connu, et certainement utilisable dans de nombreux langages, mais moi j'ai découvert aujourd'hui, et je trouve l'astuce bien élégante! ^^

Connecteur à la console SOS

-Alexandre LEGOUT aka LAlex- — Thu, 05 Jan 2006 15:58:20 +0000

Le passage à FDT n'est pas toujours sans douleurs... Les habitudes évoluent, et la façon de coder varie inmanquablement. Un des problèmes auxquels je me suis trouvé confronté a été l'utilisation de la commande 'trace', que l'on peut bien évidemment remplacer par un appel de méthode via l'option -trace de MTASC... Comme j'en ai déjà parlé, j'utilise la console SOS, pour le côté pratique de la connexion socket que sont la connexion à une console sur une machine distante, ou la gestion d'une couleur de fond différente par application (TRES utile !!!)

Le moyen que j'utilise aujourd'hui afin d'éviter les problèmes de non-importation de la classe s'occupant de se connecter à la console consiste à créer un petit répertoire utilitaire contenant les classes utiles à FDT, et de l'inclure dans mes "Linked librairies", et d'en appeler une méthode start(). Pour l'instant, seule le connecteur à la console est présent, mais il se peut que d'autres suivent (notamment mon petit framework de profiling, a venir plus tard :P)

Bref, voici ma classe SOSTracer, utilisée par MTASC avec l'option -trace SOSTracer.out :
/** * @author LAlex * @version 0.1 * @since 2006-01-05 */ class SOSTracer { // Console infos public static var SOS_HOST:String = "localhost"; public static var SOS_PORT:Number = 4444; // Used for static method 'out' private static var __instance:SOSTracer; // Used for line number display private static var __lineNumber:Number = 1; // Allow to display line numbers public static var enableLineNumber:Boolean = false; // Static function, used for MTASC -trace option // SOSTracer.start() must be called before public static function out(o) { __instance.trace(o); } // Launch the static SOSTracer with // given background color public static function start(col:Number):Boolean { __instance = new SOSTracer(col); return true; } private var _bufferize:Boolean = true; private var _socket: XMLSocket; private var _isConnected:Boolean = false; private var _color:Number; // For later ;oP // private var _itv:Number = -1; // Buffer private var _stack: Array; function SOSTracer(col:Number) { if (col != undefined) { _color = col; } _stack = []; _socket = new XMLSocket(); _socket.onConnect = function (suc) { var tr = arguments.callee.tracer; tr._connected(suc); }; _socket.onConnect.tracer = this; _socket.connect(SOS_HOST, SOS_PORT); } // Launched on socket connection private function _connected(sc:Boolean) { if (sc) { if (_color != undefined) { _socket.send("!SOS<appColor>" + _color + "</appColor>"); } _flush(); _isConnected = true; } else { _bufferize = false; throw new Error("SOS Socket connection failed"); } } // Flush buffer private function _flush() { while(_stack.length) _socket.send(_stack.shift()); } // Display a string (or object representation) public function trace(o) { var no:String = (enableLineNumber ? "[" + __lineNumber++ + "] " : "") + o.toString(); if (_isConnected) { _socket.send(no); } else if (_bufferize) { _stack.push(no); } } } Le but est ici d'être indépendant de tout autre package, d'où l'utilisation d'une classe XMLSocket "de base" (j'en ai implémenté une plus évoluée), et l'utilisation d'un Delegate "à la main" Afin d'éviter de surcharger la connexion, je prévois ensuite d'utiliser un système de bufferisation éventuel, au moyen du buffer utilisé avant la connexion, et d'un setInterval (vous avez surement remarqué que la propriété pour l'intervalle est déjà prévue, mais pas utilisée encore :$). Pour l'utiliser, rien de plus simple, je lance un start() dans mon main et j'utilise trace() dans mon code : public static function main() { SOSTracer.start(0XFFFFCC); // Couleur de fond dans la console }

Pour le déploiement, il suffit de changer dans MTASC l'option -trace SOSTracer.out par -trace no, et de commenter la ligne SOSTracer.start() (pas de import à commenter, du fait de l'absence de package 8))

::Télécharger SOSTracer.zip::

Simuler une énumération et/ou des contantes

-Alexandre LEGOUT aka LAlex- — Thu, 22 Dec 2005 14:12:41 +0000

Il peut être trés pratique, voire parfois indispensable pour obtenir un code "clean", de ne pouvoir passer une valeur à une méthode, qui doit obligatoirement être une des valeurs "possibles"... C'est ce que l'on appelle des énumérations. Java gère cela nativement grâce à la classe Enum.

De même, avoir la possibilité de créer des constantes est également bien utile. Dans la pratique, il s'agit en fait de créer une propriété statique en lecture seule. Le moyen le plus sûr de faire cela serait de créer une variable statique privée, et un getter statique public.

Voici ce que cela pourrait donner dans le cadre d'une classe d'encryptage:
class Crypter { // Private static members private static var _NONE:String = "none"; private static var _MD5:String = "md5"; private static var _SHA1:String = "sha1"; // Public constants public static function get NONE():String { return _NONE; } public static function get MD5():String { return _MD5; } public static function get SHA1():String { return _SHA1; } private var _cryptMode:String; function Crypter(mode:String) { _cryptMode = mode; } function encrypt(s:String):String { // Case use private vars, to avoid decreasing // performances by using a getter switch(_cryptMode) { case _NONE: return s; case _MD5: var md5crypted:String = ""; // Perform MD5 cryptage return md5crypted; case _SHA1: var sha1crypted:String = ""; // Perform SHA1 cryptage return sha1crypted; } } } // Usage var myCrypter:Crypter = new Crypter(Crypter.MD5); trace(myCrypter.encrypt("String to be encrypted")); Bien que tout cela soit quand-même assez clean, cette implémentation pose quelques problèmes:

Tout accés aux constantes (de l'exterieur) fait appel à un getter, et donc les performances peuvent s'en ressentir, selon la fréquence de ces accés
Il est possible de passer au constructeur une chaine de caractères qui ne fasse pas partie des valeurs attendues en entrée... Cela peut se résoudre avec un default: dans le case, mais ce n'est pas vraiment une solution satisfaisante...

Dans les premières betas de la librairie de petepx, pixLib, j'avais noté l'utilisation trés élégante qu'avait fait Francis de l'héritage de String pour le typage de ses types d'évenements (classe EventType si je ne m'abuse). A priori, il s'agissait surtout, dans ce cas, de polymorphisme avec EventDispatcher de Macromedia, mais j'ai alors étendu le concept pour pouvoir créer mes énumérations, dans une classe externe.

// Enum

class CryptMode

        extends String {

        public static var NONE:CryptMode = new CryptMode("none");

        public static var MD5:CryptMode = new CryptMode("md5");

        public static var SHA1:CryptMode = new CryptMode("sha1");

        private function CryptMode(content:String) {

                super(content);

        }

}

class Crypter {

        private var _cryptMode:CryptMode;

        function Crypter(mode:CryptMode) {

                _cryptMode = mode;

        }

        function encrypt(s:String):String {

                // Case use private vars, to avoid decreasing

                // performances by using a getter

                switch(_cryptMode) {

                        case CryptMode.NONE:

                                return s;

                        case CryptMode.MD5:

                                var md5crypted:String = "";

                                // Perform MD5

                                return md5crypted;

                        case CryptMode.SHA1:

                                var sha1crypted:String = "";

                                // Perform SHA1

                                return sha1crypted;

                }

        }

}

// Usage

var myCrypter:Crypter = new Crypter(CryptMode.MD5);

trace(myCrypter.encrypt("String to be encrypted"));

Cette méthode à tous les avantages:

Impossible de rajouter des constantes non-prévues au runtime, du fait du constructeur privé.
Toujours grâce au constructeur privé, impossible de modifier la valeur d'une constante, bien qu'il s'agisse d'une propriété publique.
Impossible de passer une valeur non prévue à une méthode, si l'argument est typé avec l'énumération.
Une compatibilité avec les types de bases. Bien que l'exemple se base sur un héritage de String, il est bien sûr possible de l'utiliser sur n'importe quel type "de base" (Number par exemple) comme sur des types plus complexes. Le '==' continue de fonctionner par exemple :trace(CryptMode.MD5 == "md5"); // true
Petit bémol, le switch...case semble utiliser une comparaison stricte (===), donc ne pas oublier de faire un toString() ou valueOf() dans ce cas...
Remplace presque parfaitement le fait de ne pas pouvoir créer de constantes dans les interfaces, offrant ainsi la possibilité de disposer d'une série de valeurs dans la création d'une API "pure" (sans aucune implémentation).

Bref, je suis assez content d'avoir trouvé ce moyen de rendre mes codes un peu plus clean. J'utilise dorénavant énormément cette astuce, notamment concernant la diffusion d'évenements, en créant une classe collection contenant les évenements diffusables par une classe définie, puis en utilisant le typage dans la signature de mes addEventListener (en parlant de ça, bientôt un tool de diffusion d'évenements maison).

Wala, wala! ^^

Bug du compilateur Flash 8 (...et moins?)

-Alexandre LEGOUT aka LAlex- — Fri, 09 Dec 2005 17:02:05 +0000

Le compilateur de Flash 8 semble contenir un bug qui, s'il est mineur, peut provoquer quelques arrachages de cheveux. En fait, lorsque l'on hérite d'une classe en précisant son chemin complet (donc sans import), le compilo va la considérer comme importée, mais ce n'est pas le cas à l'éxecution. La où l'on s'attend donc à obtenir une erreur de compilation, tout se passe bien, et on comprend donc mal où est l'erreur... :\

Petit exemple :class com.lalex.myappli.CustomSocket extends com.lalex.net.ExtendedSocket { function CustomSocket() { /** * ExtendedSocket.CONNECT_FAILED sera 'undefined' * car on a pas importé com.lalex.net.ExtendedSocket * Pourtant, le compilo laisse passer */ addEventListener(ExtendedSocket.CONNECT_FAILED, this, handleConnectionFail); } private function handleConnectionFail(o) { trace("Connection failed"); } }
Bon, je vous l'accorde, on pourrait dire "Ben il n'avait qu'à importer la classe", ou "Il n'avait qu'à donner le chemin complet de la classe!"... mais le compilateur n'est-il pas là pour nous signaler ce genre d'oublis? :o

Typage :Object, le retour

-Alexandre LEGOUT aka LAlex- — Tue, 15 Nov 2005 17:03:47 +0000

Eh oui, ce détail anodin du compilateur qui nous empêchait de typer avec Object est enfin résolu dans Flash 8. Je trouve ca bien, ca permet de spécifier explicitement que n'importe quel objet peut être transmis en paramètre ou affecté à une variable, et cela fait aussi bien la différence aussi entre une méthode qui ne retourne rien (Void) et un objet quelconque (Object)...

PS: Je suis en plein dans les entrailles de la communication temps réel actuellement: Flash Media Server 2 et connexions XMLSocket... Je devrais avoir de la matière sur ce blog prochainement!