VEGAS - Design Pattern d'inversion de contrôle : Définitions d'objets

Date de publication : 11/09/2009

Version PDF (Miroir) Version hors-ligne (Miroir)

V. Les attributs "evaluators"
V-A. Description et utilisation de l'interface Evaluable
V-A-1. La classe system.evaluators.DateEvaluator
V-A-2. La classe system.evaluators.EdenEvaluator
V-A-3. La classe system.evaluators.MathEvaluator
V-A-4. La classe system.evaluators.MultiEvaluator
V-A-5. La classe system.evaluators.PropertyEvaluator
V-B. Les implémentations de l'interface Evaluable dans le package andromeda.ioc.*
V-B-1. La classe ConfigEvaluator
V-B-2. La classe LocaleEvaluator
V-B-3. La classe ReferenceEvaluator
V-B-4. La classe TypeEvaluator
V-C. Utilisation des objets Evaluable dans les définitions d'objets
V-C-1. Évaluation dans une fonction constructeur
V-C-2. Évaluation dans l'attribut "properties"
V-C-3. Évaluation dans les attributs "factoryMethod" et "staticFactoryMethod"

V. Les attributs "evaluators"

Cet attribut définit une fonctionnalité un peu spéciale dans les définitions d'objets, il peut être utilisé essentiellement dans dans les objets génériques définis dans les attributs "properties" et "arguments".

Cet attribut est une collection (Array) contenant soit des objets dont la classe implémente l'interface system.evaluators.Evaluable, soit des expressions (String) qui permettront de cibler dans la fabrique une référence d'un objet qui implémentera lui aussi l'interface system.evaluators.Evaluable.

V-A. Description et utilisation de l'interface Evaluable

L'interface system.evaluators.Evaluable est définie dans le package system.evaluators.* du framework ES4a (Maashaack) développé par Zwetan et moi même dans le cadre d'un projet de framework standard et bas niveau défini pour les langages basés sur les normes ECMASCript 4.

L'interface system.evaluators.Evaluable est très simple, elle définit l'existence d'une méthode eval(o:*):* dans une classe. Cette interface permet à tout moment de créer des classes concrètes qui permettront en fonction des problèmes et des besoins d'une application de filtrer ou de transformer certains objets. Il ne faut pas hésiter à utiliser cette interface dans vos applications.


package system.evaluators 
{
    public interface Evaluable 
    {
        function eval( o:* ):* ;
    }
}

Cette interface possède quelques classes concrètes intéressante contenues dans le package system.evaluators.*.

V-A-1. La classe system.evaluators.DateEvaluator

Elle permet d'évaluer un objet de type Date et de renvoyer une chaine de caractère formatée en conséquence.


import system.evaluators.DateEvaluator ;
 
var evaluator:DateEvaluator = new DateEvaluator() ;
 
evaluator.pattern = "hh 'h' nn 'mn' ss 's' TT" ;
 
trace( evaluator.eval( new Date(2008,1,21,14,15,0,0) ) ) ; // 02 h 15 mn 00 s PM

Je vous conseille de lire attentivement la documentation de la classe system.formatters.DateFormatter pour en savoir plus sur le pattern qu'il est possible d'utiliser pour évaluer l'objet de type Date avec un DateEvaluator.

V-A-2. La classe system.evaluators.EdenEvaluator

Elle permet d'évaluer une chaine de caractère au format eden et de renvoyer un objet désérialisé ou sérialisé correspondant.


import system.evaluators.EdenEvaluator ;
 
var e:EdenEvaluator = new EdenEvaluator( false ) ;
 
var result:Date = e.eval( "new Date(2007,5,12,22,10,5)" ) ;
 
trace( result ) ; // Tue Jun 12 22:10:05 GMT+0200 2007

V-A-3. La classe system.evaluators.MathEvaluator

Elle permet d'évaluer une chaine de caractère contenant une expression mathématiques plus ou moins complexe et de renvoyer le résultat de cette expression.


import system.evaluators.MathEvaluator ;
 
var init:Object =
{
    x      : 100 ,
    square : function(a:Number):Number {return a*a;}
}
 
var e:MathEvaluator = new MathEvaluator( init ) ;
 
var result:Number = e.eval( "( 2 + square(x) ) / 2" ) ;
 
trace( result ) ; // 5001

V-A-4. La classe system.evaluators.MultiEvaluator

Elle permet de chainer plusieurs objets de type Evaluable pour lancer une évaluation successive d'un objet et le transformer en un autre objet en combinant tous les objets Evaluable enregistrés.


import system.evaluators.* ;
 
var e1:EdenEvaluator = new EdenEvaluator(false) ;
var e2:DateEvaluator = new DateEvaluator() ;
 
var result:* ;
 
var me:MultiEvaluator = new MultiEvaluator( e1, e2 ) ;
 
result = me.eval( "new Date(2007,5,12,22,10,5)" ) ;
 
trace("evaluate new Date(2007,5,12,22,10,5) : " + result ) ;
// output: evaluate new Date(2007,5,12,22,10,5) : 12.06.2007 22:10:05
 
me.clear() ; // clear all evaluators
 
me.add( e1 , e2 ) ;
 
result = me.eval("new Date(2007,5,12,22,10,5)") ;
 
trace("evaluate new Date(2007,5,12,22,10,5) : " + result ) ;
// output: evaluate new Date(2007,5,12,22,10,5) : 12.06.2007 22:10:05
 
me.remove( e2 ) ;
 
result = me.eval("new Date(2007,5,12,22,10,5)") ;
 
trace("evaluate new Date(2007,5,12,22,10,5) : " + result ) ;
// output: evaluate new Date(2007,5,12,22,10,5) : Tue Jun 12 22:10:05 GMT+0200 2007

V-A-5. La classe system.evaluators.PropertyEvaluator

Cette classe évalue une expression (String) et renvoie la valeur d'une propriété définie dans un objet. Cette expression peut être définie avec une syntaxe pointée sur plusieurs niveaux pour cibler précisément en profondeur dans l'objet une valeur en particulier.


import system.evaluators.PropertyEvaluator ;
 
var obj:Object =
{
     message : "hello world" ,
     title   : "my title"    ,
     menu    :
     {
         title : "my menu title" ,
         label : "my label"
     }
}
 
var evaluator:PropertyEvaluator = new PropertyEvaluator( obj ) ;
 
trace( evaluator.eval( "test"       ) ) ; // null
trace( evaluator.eval( "message"    ) ) ; // hello world
trace( evaluator.eval( "title"      ) ) ; // my title
trace( evaluator.eval( "menu.title" ) ) ; // my menu title
trace( evaluator.eval( "menu.label" ) ) ; // my label

Cette classe peut être utilisée seule ou par héritage, nous verrons par exemple dans la suite de ce chapitre les classes ConfigEvaluator et LocaleEvaluator qui héritent de la classe PropertyEvaluator.

V-B. Les implémentations de l'interface Evaluable dans le package andromeda.ioc.*

Dans AndromedAS le moteur IoC utilise lui aussi pour simplifier certains processus des objets qui implémentent l'interface Evaluable, nous pouvons donc regarder de plus prêt dans le package andromeda.ioc.evaluators.

V-B-1. La classe ConfigEvaluator

Cette classe hérite de la classe system.evaluators.PropertyEvaluator, et cible un objet de type ObjectConfig qui contient la configuration interne d'une fabrique IoC.

Dans les objets de type ObjectConfig il existe un attribut "config" dynamique qui permet de définir des variables qui seront utilisées le moment voulu dans l'application ou dans les définitions d'objets du conteneur léger.

Les objets de type ConfigEvaluator pourront donc évaluer une expression (String) et renvoyer la valeur d'une variable définie dans l'objet de configuration dynamique de la fabrique :


import andromeda.ioc.evaluators.ConfigEvaluator;
 
import andromeda.ioc.factory.ObjectConfig ;
 
var init:Object =
{
    message : "hello world" ,
    menu    :
    {
        title : "my title" ,
        count : 10 ,
        data  : [ "item1" , "item2", "item3" ]
    }
}
 
var configurator:ObjectConfig = new ObjectConfig() ;
 
configurator.config = init ;
 
var evaluator:ConfigEvaluator = new ConfigEvaluator( configurator ) ;
 
trace( evaluator.eval( "test"       ) ) ; // null
trace( evaluator.eval( "message"    ) ) ; // hello world
trace( evaluator.eval( "menu"       ) ) ; // [object Object]
trace( evaluator.eval( "menu.title" ) ) ; // my title
trace( evaluator.eval( "menu.count" ) ) ; // 10
trace( evaluator.eval( "menu.data"  ) ) ; // item1,item2,item3
trace( evaluator.eval( "menu.test"  ) ) ; // null

Nous traiterons en détail cette fonctionnalité dans le prochain chapitre concernant l'attribut "configuration" du contexte de configuration d'une fabrique IoC.

V-B-2. La classe LocaleEvaluator

Cette classe hérite de la classe system.evaluators.PropertyEvaluator et cible un objet de type ObjectConfig qui contient la configuration interne d'une fabrique IoC.

Cette classe fonctionne comme la classe ConfigEvaluator définie ci-dessus sauf qu'elle évalue une expression (String) et renvoie une valeur définie dans l'objet "locale" de l'objet de type ObjectConfig.


import andromeda.ioc.evaluators.LocaleEvaluator;
import andromeda.ioc.factory.ObjectConfig ;
 
var init:Object =
{
     message : "hello world" ,
     title   : "my title"    ,
     menu    :
     {
         title : "my menu title" ,
         label : "my label"
     }
}
 
var configurator:ObjectConfig = new ObjectConfig() ;
 
configurator.locale = init ;
 
var evaluator:LocaleEvaluator= new LocaleEvaluator( configurator ) ;
 
trace( evaluator.eval( "test"       ) ) ; // null
trace( evaluator.eval( "message"    ) ) ; // hello world
trace( evaluator.eval( "title"      ) ) ; // my title
trace( evaluator.eval( "menu.title" ) ) ; // my menu title
trace( evaluator.eval( "menu.label" ) ) ; // my label

Nous traiterons également en détail cette fonctionnalité dans le prochain chapitre concernant l'attribut "configuration" du contexte de configuration d'une fabrique IoC.

V-B-3. La classe ReferenceEvaluator

Cette classe est utilisée dans les définitions d'objets, elle permet d'évaluer une expression (String) et de renvoyer une référence d'un objet défini dans la fabrique ou plus finement la valeur d'un attribut spécifique d'une de ces références.


import andromeda.ioc.evaluators.ReferenceEvaluator ;
import andromeda.ioc.factory.ECMAObjectFactory ;
 
import andromeda.vo.FilterVO ;
 
var linkages:Array = [ FilterVO ] ;
 
var objects:Array =
[
    {
        id         : "VIDEO" ,
        type       : "andromeda.vo.FilterVO" ,
        properties : [ { name : "filter" , value : 1 } ]
    }
    ,
    {
        id         : "MP3" ,
        type       : "andromeda.vo.FilterVO" ,
        properties : [ { name : "filter" , value : 2 } ]
    }
    ,
    {
        id         : "my_filter" ,
        type       : "andromeda.vo.FilterVO" ,
        properties :
        [
            { name:"toggleFilter" , arguments:[ { ref : "VIDEO.filter" } , { value : true } ] } ,
            { name:"toggleFilter" , arguments:[ { ref : "MP3.filter"   } , { value : true } ] }
        ]
    }   
];
 
var factory:ECMAObjectFactory = ECMAObjectFactory.getInstance() ;
 
factory.create( objects ) ;
 
var evaluator:ReferenceEvaluator = new ReferenceEvaluator( factory ) ;
 
// test evaluator
 
trace( evaluator.eval( "DISK" ) ) ; // null
trace( evaluator.eval( "VIDEO" ) ) ; // [FilterVO:1]
trace( evaluator.eval( "VIDEO.filter" ) ) ; // 1
 
// test in the factory
 
trace( factory.getObject( "my_filter" ) ) ; // [FilterVO:3]

Dans l'exemple ci-dessus, j'utilise la classe andromeda.vo.FilterVO ( un simple "value object" ) qui permet de stocker une valeur binaire via un attribut numérique "filter". Cette classe est très pratique dans une application pour gérer des filtrages binaires sans avoir à passer par une multitude d'objets de type Boolean. L'exemple précédent illustre d'ailleurs bien la possibilité de créer des énumérations de valeurs uniques binaires et de combiner selon les besoins les filtres de cette énumération avec la classe FilterVO.

En ActionScript, nous pouvons par exemple observer un comportement similaire avec les filtres définis dans la classe Array avec les constantes statiques : Array.NUMERIC, Array.DESCENDING, etc. Ces filtres permettent de définir les options que nous pouvons utiliser lors du tri d'un Array avec les méthodes sort() ou sortOn().

V-B-4. La classe TypeEvaluator

Cette classe est utilisée pour évaluer l'attribut "type" dans une définition d'objet.

L'attribut "type" contient une expression (String) qui de façon général représente le nom complet d'une classe définie en natif dans le FlashPlayer ou directement dans le code source de votre application (voir chapitre B-1-2). Cette expression est donc directement évaluée et si une référence de la classe concernée existe dans l'animation, la fabrique pourra en cas de besoin générer une instance de cette classe.

L'évaluation du nom complet de classe n'est pas la seule fonctionnalité des objets de type andromeda.ioc.evaluators.TypeEvaluator. Cette classe permet de simplifier les expressions définies dans les attributs "type" d'une définition d'objet avec la possibilité d'utiliser 2 stratégies simples basées sur un filtrage de l'expression (String) avec :

Une collection d'alias simple qui permet de simplifier la définition du type d'une définition d'objet selon les besoins.
Un dictionnaire d'expressions qui permettra de formater en cas de besoin le type défini dans une définition d'objet.

Ces stratégies peuvent être utilisées en même temps ou séparément selon les besoins d'optimisation d'un contexte externe de configuration d'une fabrique IoC.

Voyons maintenant un exemple d'utilisation simplifié de la classe TypeEvaluator :


import andromeda.ioc.core.TypePolicy ;
import andromeda.ioc.evaluators.TypeEvaluator ;
import andromeda.ioc.factory.ObjectConfig ;
 
var conf:ObjectConfig = new ObjectConfig() ;
 
conf.typePolicy       = TypePolicy.ALL ; // or: TypePolicy.NONE, TypePolicy.ALIAS, TypePolicy.EXPRESSION
 
conf.typeAliases      =
[
     { alias:"CoreObject" , type:"vegas.core.CoreObject" }
] ;
 
conf.typeExpression   =
[
    { name:"map"     , value:"vegas.data.map" } ,
    { name:"HashMap" , value:"{map}.HashMap"  }
] ;
 
var evaluator:TypeEvaluator = new TypeEvaluator( conf ) ;
 
trace( evaluator.eval( "vegas.core.CoreObject" ) ) ; // [class CoreObject]
trace( evaluator.eval( "CoreObject"  ) ) ; // [class CoreObject]
trace( evaluator.eval( "{HashMap}"   ) ) ; // [class HashMap]
trace( evaluator.eval( "test"        ) ) ; // null
trace( evaluator.eval( "{map}.Test"  ) ) ; // null

L'exemple ci-dessus illustre le lien que peuvent avoir la configuration d'une fabrique IoC et un objet de type TypeEvaluator. Cette évaluation est bien entendu totalement transparente une fois utilisée dans une fabrique basée sur le modèle IoC implémenté dans AndromedAS.

Nous verrons par la suite un descriptif complet de l'utilisation de la configuration d'un conteneur léger IoC avec les attributs typePolicy, typeAliases et typeExpression ( voir chapitre C-1-7 - Les attributs de configuration des types dans les définitions d'objets ).

V-C. Utilisation des objets Evaluable dans les définitions d'objets

Maintenant que nous avons pu voir comment fonctionne les objets de type Evaluable dans une application, il va être beaucoup intéressant d'observer l'utilisations de ces objets dans les définitions d'objets d'une fabrique IoC.

Dans les définitions d'objets nous pouvons donc définir un attribut "evaluators" dans certains cas de figure. Cet attribut sera toujours défini avec une collection (Array) d'objets de type Evaluable ou d'identifiants de type String.

Tous les identifiants définis dans la collection "evaluators" permettent de cibler des références d'autres définitions d'objets dans la fabrique courante sous condition que ces définitions d'objets soient définies avec un "type" qui implémente l'interface Evaluable. Tout autre objet défini dans cette collection (Array) sera ignoré.

Nous pouvons trouver l'attribut "evaluators" dans les définitions d'objets dans les attributs : "properties" et "arguments".

Nous avons vu précédement dans le chapite B-4-1-4 l'utilisation de la classe MultiEvaluator. Il faut donc considérer que c'est cette classe qui permet le filtrage des valeurs dans les propriétés et arguments définis dans les définitions d'objets pendant qu'un objet et ses dépendances sont créés.

Pour illustrer de façon complète l'utilisation de cette fonctionnalité nous allons réaliser un petit exemple qui utilisera :

2 classes simples test.Appointment et test.factory.AppointmentFactory (définies un peu plus bas).
Les classes system.evaluators.DateEvaluator et system.evaluators.EdenEvaluator définies un peu plus haut dans ce chapitre.

Pour commencer nous allons définir la classe test.Appointment :


package test
{
 
    /**
     * Represents a commitment representing a time interval with start and end times and a duration.
     */
    public class Appointment
    {
 
        /**
         * Creates a new Appointment instance.
         */
        public function Appointment( scheduledStart:String = null , scheduledEnd:String = null )
        {
            this.scheduledEnd   = scheduledEnd   ;
            this.scheduledStart = scheduledStart ;
        }
 
        /**
         * Indicates the scheduled end time of the appointment.
         */
        public var scheduledEnd:String ;
 
        /**
         * Indicates the scheduled start time of the appointment.
         */
        public var scheduledStart:String ;
 
        /**
         * The subject of the appointment.
         */
        public var subject:String ;
 
        /**
         * Defines the start and the end of the appointment.
         */
        public function setShedule( start:String , end:String ):void
        {
            scheduledStart = start ;
            scheduledEnd   = end ;
        }
 
    }
 
}

Cette classe va nous permettre d'illustrer l'utilisation de l'attribut "evaluators" dans les attributs "properties" et "arguments" d'une définition d'objet aussi bien dans la fonction constructeur que dans les différentes propriétés (attributs et méthodes) définies pour initialiser l'objet au moment de sa création.

Ensuite nous pouvons définir la classe test.factory.AppointmentFactory :


package test.factory
{
    import test.Appointment;           
 
    /**
     * This factory creates Appointment instances.
     */
    public class AppointmentFactory
    {
 
        /**
         * Creates a new Appointment instance.
         */
        public function build( scheduledStart:String = null , scheduledEnd:String = null ):Appointment
        {
            return new Appointment( scheduledStart, scheduledEnd ) ;
        }
 
        /**
         * Creates a new Appointment instance (static method).
         */
        public static function create( scheduledStart:String = null , scheduledEnd:String = null  ):Appointment
        {
            return new Appointment( scheduledStart, scheduledEnd ) ;
        }
 
    }
}

Cette classe contient une méthode classique build() et une méthode statique create().

Cette classe va nous permettre d'illustrer l'utilisation de l'attribut "evaluators" dans le cadre des stratégies basées sur les attributs "factoryMethod" et "staticFactoryMethod".

Nous finissons cet exemple plusieurs petits bout de code qui permet de définir selon les cas plusieurs stratégies avec à chaque fois une évaluation d'une expression (String) contenant une représentation eden d'un objet de type Date qui sera évalué tout d'abord avec un objet de type EdenEvaluator et ensuite avec un objet de type DateEvaluator.

V-C-1. Évaluation dans une fonction constructeur


import andromeda.ioc.factory.ECMAObjectFactory;
 
import system.evaluators.* ;
 
var objects:Object =
[
    {  
        id         : "my_date"  ,
        type       : "String" ,
        arguments  :
        [
            {
                value      : "new Date(2007,11,5,10,22,33)" ,
                evaluators :
                [
                    new system.evaluators.EdenEvaluator(false) ,
                    new system.evaluators.DateEvaluator()
                ]
            }
        ]
    }
] ;
 
var factory:ECMAObjectFactory = ECMAObjectFactory.getInstance() ;
 
factory.create( objects ) ;   
 
trace( "---- test evaluators in the constructor arguments" ) ;
 
trace( "my date : " + factory.getObject("my_date") ) ;
//output: my_date : 05.12.2007 10:22:33

V-C-2. Évaluation dans l'attribut "properties"


import andromeda.ioc.factory.ECMAObjectFactory;
 
import test.Appointment ;
 
import system.evaluators.* ;
 
var objects:Object =
[
 
    // evaluators
 
    {
        id        : "eden" ,
        type      : "system.evaluators.EdenEvaluator" ,
        singleton : true ,
        arguments : [ { value:false } ]
    }
    ,
    {
        id        : "date" ,
        type      : "system.evaluators.DateEvaluator" ,
 
        singleton : true
    }
 
    , 
 
    // test attributes ("properties")
 
    {  
        id         : "appointment_01"   ,
        type       : "test.Appointment" ,
        properties :
        [
            {
                name       : "scheduledStart" ,
                value      : "new Date(2008,5,30,10,30,00)" ,
                evaluators : [ "eden" , "date" ]
            }
            ,
            {
                name       : "scheduledEnd" ,
                value      : "new Date(2008,5,30,12,40,00)" ,
                evaluators :
                [
                    "eden" ,
                    new system.evaluators.DateEvaluator()
                ]
            }
        ]
    }
 
    ,
 
    // test methods ("properties")
 
    {  
        id         : "appointment_02"   ,
        type       : "test.Appointment" ,
        properties :
        [
            {
                name       : "setShedule" ,
                arguments  :
                [
                    {
                        value      : "new Date(2008,5,30,14,00,00)" ,
                        evaluators :
                        [
                            new system.evaluators.EdenEvaluator(false) ,
                            "date"
                        ]
                    }
                    ,
                    {
                        value      : "new Date(2008,5,30,16,30,00)" ,
                        evaluators : [ "eden" , "date" ]
                    }
                ]
            }
        ]
    }
 
] ;
 
var factory:ECMAObjectFactory = ECMAObjectFactory.getInstance() ;
 
factory.create( objects ) ;   
 
var app:Appointment ;
 
trace( "---- test evaluators in attributes" ) ;
 
app = factory.getObject("appointment_01") as Appointment ;
 
trace( "> start  : " +  app.scheduledStart ) ;
//output: > start  : 30.06.2008 10:30:00
 
trace( "> finish : " +  app.scheduledEnd ) ;
//output: > finish : 30.06.2008 12:40:00
 
trace( "---- test evaluators in methods" ) ;
 
app = factory.getObject("appointment_02") as Appointment ;
 
trace( "> start  : " +  app.scheduledStart ) ;
//output: > start  : 30.06.2008 14:00:00
 
trace( "> finish : " +  app.scheduledEnd ) ;
//output: > finish : 30.06.2008 16:30:00

L'exemple ci-dessus illustre l'utilisation de l'attribut "evaluators" avec des identifiants permettant de cibler d'autres définitions d'objets dans la fabrique ou directement des objets Evaluable définis dans le contexte de la fabrique.

V-C-3. Évaluation dans les attributs "factoryMethod" et "staticFactoryMethod"


import andromeda.ioc.factory.ECMAObjectFactory ;
 
import test.Appointment ;
import test.factory.AppointmentFactory ;
 
import system.evaluators.* ;
 
var linkageEnforcer:Array =
[
    AppointmentFactory
] ;
 
var objects:Object =
[
 
    // evaluators
 
    {
        id        : "eden" ,
        type      : "system.evaluators.EdenEvaluator" ,
        singleton : true ,
        arguments : [ { value:false } ]
    }
    ,
    {
        id        : "date" ,
        type      : "system.evaluators.DateEvaluator" ,
        singleton : true
    }
 
    ,
 
    // factory method
 
    {
        id   : "appointment_factory"   ,
        type : "test.factory.AppointmentFactory"
    }
    ,
    {  
        id            : "appointment_03"   ,
        type          : "test.Appointment" ,
        factoryMethod :
        {
            factory    : "appointment_factory" ,
            name       : "build" ,
            arguments  :
            [
                {
                    value      : "new Date(2008,6,30,14,00,00)" ,
                    evaluators : [ "eden" , "date" ]
                }
                ,
                {
                    value      : "new Date(2008,6,30,16,30,00)" ,
                    evaluators : [ "eden" , "date" ]
                }
            ]
        }
    }
 
    ,
 
    // static factory method
 
    {  
        id                  : "appointment_04"   ,
        type                : "test.Appointment" ,
        staticFactoryMethod :
        {
            type       : "test.factory.AppointmentFactory" ,
            name       : "create" ,
            arguments  :
            [
                {
                    value      : "new Date(2008,7,30,16,00,00);" ,
                    evaluators : [ "eden" , "date" ]
                }
                ,
                {
                    value      : "new Date(2008,7,30,17,00,00);" ,
                    evaluators : [ "eden" , "date" ]
                }
            ]
        }
    }   
 
] ;
 
var factory:ECMAObjectFactory = ECMAObjectFactory.getInstance() ;
 
factory.create( objects ) ;   
 
var app:Appointment ;
 
trace( "---- test evaluators in factory method strategy" ) ;
 
app = factory.getObject("appointment_03") as Appointment ;
 
trace( "> start  : " +  app.scheduledStart ) ;
//output: > start  : 30.07.2008 14:00:00
 
trace( "> finish : " +  app.scheduledEnd   ) ;
//output: > finish : 30.07.2008 16:30:00
 
trace( "---- test evaluators in static factory method strategy" ) ;
 
app = factory.getObject("appointment_04") as Appointment ;
 
trace( "> start  : " +  app.scheduledStart ) ;
//output: > start  : 30.08.2008 16:00:00
 
trace( "> finish : " +  app.scheduledEnd   ) ;
//output: > finish : 30.08.2008 17:00:00

Précédent Sommaire

Version PDF (Miroir) Version hors-ligne (Miroir)

Copyright © 2009 test. Aucune reproduction, même partielle, ne peut être faite de ce site ni de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.