Changeset 24

Show
Ignore:
Timestamp:
02/01/08 17:45:54 (1 year ago)
Author:
skit
Message:

Ajout de la classe AbstractLocator? (pyxoo.core)
ModelLocator? et ViewLocator? étendent cette classe.
Test de doc

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • project/trunk/src/pyxoo/__init__.py

    r23 r24  
    2020__version__ = "0.1" 
    2121__author__  = "Alexis Couronne" 
    22 __url__     = "www.pyxoo.org" 
     22__url__     = "http://www.pyxoo.org" 
    2323 
    2424 

  • project/trunk/src/pyxoo/command.py

    r23 r24  
    234234 
    235235class Delegate( Command ):     
    236     __logger = logging.getLogger( "Pyxoo.Command.delegate.Delegate" ) 
     236    __logger = logging.getLogger( "pyxoo.command.Delegate" ) 
    237237     
    238238    @classmethod 

  • project/trunk/src/pyxoo/core.py

    r23 r24  
    11 
    2 import pyxoo, sys 
     2import pyxoo, sys, logging 
    33 
    44__version__ = pyxoo.__version__ 
    …… 
    2020     
    2121    def isRegistered( self, key ): 
    22         """isRegistered(string):boolean 
     22        """ 
    2323        Returns true is there is a ressource associated 
    2424        with the passed-in key. To avoid errors when 
    …… 
    2727        ressource you would access is already accessible before any 
    2828        call to the locate function. 
     29        @type key: String 
     30        @rtype: Boolean  
    2931        """ 
    3032     
    3133    def locate( self, key ): 
    32         """locate(string):object 
     34        """ 
    3335        Returns the ressource associated with the passed-in key. 
    3436        If there is no ressource identified by the passed-in key, the 
    …… 
    3638        when attempting to access to a ressource, take care to check the 
    3739        existence of the ressource before trying to access to it. 
     40        @type key: String 
     41        @rtype: Object  
    3842        """ 
    3943         
    40     def add(self, dictionnary): 
    41         """add(dict):void 
     44    def add( self, dictionnary ): 
     45        """ 
    4246        Adds all ressources contained in the passed-in dictionnary 
    4347        into this locator instance. If there is keys used both in 
    4448        the locator and in the dictionnary an exception is thrown. 
    45         """ 
     49        @type dictionnary: dict 
     50        @rtype: void 
     51        """ 
     52 
     53 
     54 
     55class AbstractLocator( Locator ): 
     56    __logger = logging.getLogger( "pyxoo.core.AbstractLocator" ) 
     57    def __init__( self, typeObject=None, typeListener=None ): 
     58        """ 
     59        Creates a new locator instance. If the type 
     60        argument is defined, the locator is considered as typed, and 
     61        then the type of all elements inserted in this set is checked. 
     62        @param typeObject: Can be None 
     63        @param typeListener: Can be None  
     64        @type typeObject: Class or Type 
     65        @type typeListener: Class or Type 
     66        """ 
     67        self.__type = typeObject 
     68        self.__elements = pyxoo.utils.HashMap( str, self.__type ) 
     69        self.__eventBroadcaster = pyxoo.event.EventBroadcaster( self, typeListener ) 
     70         
     71    def onRegister( self, name=None, object=None ): 
     72        """ 
     73        override me if you need me 
     74        @param name: Can be None 
     75        @param object: Can be None 
     76        @type name: String 
     77        @type object: Object 
     78        @rtype: void 
     79        """ 
     80        pass 
     81     
     82    def onUnregister( self, name=None ): 
     83        """ 
     84        override me if you need me 
     85        @param name: Can be None 
     86        @type name: String 
     87        @rtype: void 
     88        """ 
     89        pass 
     90         
     91    def isRegistered( self, name ): 
     92        """ 
     93        Returns true is there is a ressource associated 
     94        with the passed-in key. To avoid errors when 
     95        retreiving ressources from a locator you should systematically 
     96        use the isRegistered function to check if the 
     97        ressource you would access is already accessible before any 
     98        call to the locate function. 
     99        @type name: String 
     100        @rtype: Boolean 
     101        """ 
     102        return self.__elements.containsKey( name ) 
     103     
     104    def register( self, name, object ): 
     105        """ 
     106        @type name: String 
     107        @type object: Object 
     108        @rtype: void 
     109        @raise pyxoo.exceptions.IllegalArgumentException: Raise IllegalArgumentException if an object already registered with the passed in name. 
     110        @raise TypeError: Raise TypeError if locator is typed and the passed in object is not an instance of locator type. 
     111        """ 
     112        if self.isTyped() and not isinstance( object, self.getType() ): 
     113            msg = "%s.register() failed. Item must be '%s' typed."%( self, self.getType() ) 
     114            self.__logger.error( msg ) 
     115            raise TypeError( msg ) 
     116        if self.__elements.containsKey( name ): 
     117            msg = " item is already registered with '%s' name in %s"%( name, self ) 
     118            self.__logger.error( msg ) 
     119            raise pyxoo.exceptions.IllegalArgumentException( msg ) 
     120        else: 
     121            self.__elements.put( name, object ) 
     122            self.onRegister( name, object ) 
     123   
     124     
     125    def unregister( self, name ): 
     126        """ 
     127        @type name: String 
     128        @rtype: Boolean 
     129        """ 
     130        if self.__elements.containsKey( name ): 
     131            self.__elements.remove( name ) 
     132            self.onUnregister( name ) 
     133            return True 
     134        else: 
     135            return False 
     136     
     137    def locate( self, name ): 
     138        """ 
     139        Returns the ressource associated with the passed-in key. 
     140        If there is no ressource identified by the passed-in key, the 
     141        function will fail with an error. To avoid the throw of an exception 
     142        when attempting to access to a ressource, take care to check the 
     143        existence of the ressource before trying to access to it. 
     144        @type key: String 
     145        @rtype: Object  
     146        @raise pyxoo.exceptions.NoSuchElementException: Raise NoSuchElementException if no object registered with passed in name. 
     147        """ 
     148        if self.__elements.containsKey( name ): 
     149            return self.__elements.get( name ) 
     150        else: 
     151            msg = "Can't find '%s' item with '%s' name in %s"%( self.getType(), name, self ) 
     152            self.__logger.fatal( msg ) 
     153            raise pyxoo.exceptions.NoSuchElementException( msg ) 
     154     
     155    def release( self ): 
     156        """ 
     157        Clears all association between keys and objects 
     158        registered for this locator. 
     159        @rtype: void 
     160        """ 
     161        self.__elements.clear() 
     162     
     163    def add( self, dictionnary ): 
     164        """ 
     165        Adds all ressources contained in the passed-in dictionnary 
     166        into this locator instance. If there is keys used both in 
     167        the locator and in the dictionnary an exception is thrown. 
     168        @type dictionnary: dict 
     169        @rtype: void         
     170        """ 
     171        for key, value in dictionnary.items(): 
     172            self.register( key, value ) 
     173  
     174    def matchType(self, object): 
     175        """ 
     176        Verify that the passed-in object type match the current  
     177        container element's type.  
     178        @type object: Object 
     179        @rtype: Boolean  
     180        """ 
     181        return isinstance( object, self.getType() ) or object is None 
     182     
     183    def getType(self): 
     184        """ 
     185        Return the class type of elements in this container. 
     186        An untyped container returns None, as the 
     187        wildcard type (*) is not a Class 
     188        and Object class doesn't fit for primitive types. 
     189        @rtype: Class or Type or None 
     190        """ 
     191        return self.__type 
     192     
     193    def isTyped(self): 
     194        """ 
     195        Returns true if this container perform a verification 
     196        of the type of elements. 
     197        @rtype: Boolean 
     198        """ 
     199        return self.__type is not None 
     200     
     201    def addEventListener( self, eventType, listener, *args ): 
     202        """ 
     203        Adds an event listener for the specified event type. 
     204        There is two behaviors for the addEventListener 
     205        function :  
     206        The passed-in listener is an object :  
     207        The object is added as listener only for the specified event, the object must 
     208        have a function with the same name than type or at least a 
     209        handleEvent function. 
     210        The passed-in listener is a function :  
     211        A Delegate object is created and then 
     212        added as listener for the event type. There is no restriction on the name of  
     213        the function. If the rest is not empty, all elements in it is  
     214        used as additional arguments into the delegate object.  
     215        @type eventType: String 
     216        @type listener: Object 
     217        @type *args: ...Object 
     218        @rtype: Boolean    
     219        @raise pyxoo.execeptions.UnsupportedOperationException: If the listener is an object which have neither a function with the same name than the event type nor a function called handleEvent  
     220        """ 
     221        return self.__eventBroadcaster.addEventListener( eventType, listener, *args ) 
     222     
     223    def removeEventListener( self, eventType, listener ): 
     224        """ 
     225        Removes the passed-in listener for listening the specified event. The 
     226        listener could be either an object or a function. 
     227        @type eventType: String 
     228        @type listener: Object 
     229        @rtype: Boolean    
     230        """ 
     231        return self.__eventBroadcaster.removeEventListener( eventType, listener ) 
     232     
     233    def getKeys(self): 
     234        """ 
     235        Returns an list view of the keys contained in this locator. 
     236        @rtype: list 
     237        """ 
     238        return self.__elements.getKeys() 
     239     
     240    def getValues(self): 
     241        """ 
     242        Returns an list view of the values contained in this locator. 
     243        @rtype: list 
     244        """ 
     245        return self.__elements.getValues() 
     246     
     247    def __str__( self ): 
     248        """ 
     249        Returns the string representation of this instance. 
     250        @rtype: String 
     251        """ 
     252        return pyxoo.utils.PyxooStringifier.stringify( self ) 
     253                 
     254                 
     255                 

  • project/trunk/src/pyxoo/model.py

    r23 r24  
    77__author__  = "Alexis Couronne" 
    88 
    9 class ModelLocator( pyxoo.core.Locator ): 
     9class ModelLocator( pyxoo.core.AbstractLocator ): 
    1010    __instances = pyxoo.utils.HashMap() 
    1111    class __PRIVATE:pass 
    …… 
    2525        if privateAccess is not self.__PRIVATE: 
    2626            raise IllegalAccessException( "Constructor of ModelLocator is private." ) 
    27         self.__models = pyxoo.utils.HashMap(str, AbstractModel) 
     27        pyxoo.core.AbstractLocator.__init__( self, pyxoo.model.AbstractModel ) 
    2828        self.__owner = owner       
    2929         
    …… 
    3232        Return owner.""" 
    3333        return self.__owner 
    34  
    35     def isRegistered( self, key ): 
    36         """isRegistered(String):boolean 
    37         Indicates if ModelLocator contains Model associated to passed-in key.""" 
    38         return self.__models.containsKey( key )     
    39      
    40     def locate( self, key ): 
    41         """locate(String):Model 
    42         Return Model associated to the passed-in key or None value if key not know by the locator.""" 
    43         return self.__models.get( key ) 
    4434         
    4535    def getModel( self, key ): 
    …… 
    4838        return self.locate( key ) 
    4939         
    50     def registerModel( self, key, model ): 
    51         """registerModel(String, Model):void 
    52         Registers passed-in model associated to passed-in key."""  
    53         if  not isinstance( model, AbstractModel ): 
    54             raise TypeError( "model param must be an instance of Model class." ) 
    55         if self.isRegistered( key ): 
    56             return False 
    57         self.__models.put( key, model ) 
    58         return True 
    59          
    60     def unregisterModel( self, key ):   
    61         """unregisterModel(string):void 
    62         Unregisters model associated to passed-in key."""        
    63         self.__models.remove( key ) 
    64          
    6540    def release( self ): 
    6641        """release():void""" 
    67         for model in self.__models.values(): 
     42        for model in self.getValues(): 
    6843            model.release()             
    69         self.__models.clear() 
     44        pyxoo.core.AbstractLocator.release( self ) 
    7045         
    71     def add( self, dictionnary ): 
    72         """add(dict):void""" 
    73         for key, model in dictionnary.items(): 
    74             self.registerModel( key, model ) 
    75  
    7646    def __str__( self ): 
    7747        """__str__():String 
    …… 
    10676        """release():void""" 
    10777        self.__eventBroadcaster.removeAllListeners() 
    108         from Pyxoo.Model.locator import ModelLocator 
    109         ModelLocator( self.getOwner() ).unregisterModel( self.getName() ) 
     78        pyxoo.model.ModelLocator.getInstance( self.getOwner() ).unregister( self.getName() ) 
    11079        self.__name = None 
    11180     

  • project/trunk/src/pyxoo/view.py

    r23 r24  
    3333        """release():void""" 
    3434        self._getBroadcaster().removeAllListeners() 
    35         pyxoo.view.ViewLocator( self.getOwner() ).unregisterView( self.getName() ) 
     35        pyxoo.view.ViewLocator.getInstance( self.getOwner() ).unregister( self.getName() ) 
    3636     
    3737    def getOwner( self ): 
    …… 
    9393         
    9494         
    95 class ViewLocator( pyxoo.core.Locator ): 
     95class ViewLocator( pyxoo.core.AbstractLocator ): 
    9696    __instances = pyxoo.utils.HashMap() 
    9797    class __PRIVATE:pass 
    …… 
    111111        if privateAccess is not self.__PRIVATE: 
    112112            raise IllegalAccessException( "Constructor of ViewLocator is private." ) 
    113         self.__views = pyxoo.utils.HashMap( str, pyxoo.view.AbstractView ) 
     113        pyxoo.core.AbstractLocator.__init__( self, pyxoo.view.AbstractView ) 
    114114        self.__owner = owner 
    115115     
    …… 
    118118        Return owner.""" 
    119119        return self.__owner 
    120      
    121     def isRegistered( self, key ): 
    122         """isRegistered(string):boolean 
    123         Indicates if ViewLocator contains View associated to passed-in key.""" 
    124         return self.__views.containsKey( key )     
    125      
    126     def locate( self, key ): 
    127         """locate(string):View 
    128         Return View associated to the passed-in key or None value if key not know by the locator.""" 
    129         return self.__views.get( key ) 
    130120         
    131121    def getView( self, key ): 
    …… 
    134124        return self.locate( key ) 
    135125         
    136     def registerView( self, key, view ): 
    137         """registerView(string, View):boolean 
    138         Registers passed-in view associated to passed-in key."""  
    139         if  not isinstance( view, AbstractView ): 
    140             raise TypeError( "view param must be an instance of View class." ) 
    141         if self.isRegistered( key ): 
    142             return False 
    143         else: 
    144             self.__views.put( key, view ) 
    145             return True 
    146          
    147     def unregisterView( self, key ): 
    148         """unregisterView(string):void 
    149         Unregisters view associated to passed-in key."""         
    150         self.__views.remove( key ) 
    151          
    152126    def release( self ): 
    153127        """release():void""" 
    154         for view in self.__views.values(): 
     128        for view in self.getValues(): 
    155129            view.release()             
    156         self.__views.clear() 
    157          
    158     def add( self, dictionnary ): 
    159         """add(dict):void""" 
    160         for key, view in dictionnary.items(): 
    161             self.registerView( key, view ) 
     130        pyxoo.core.AbstractLocator.release( self ) 
    162131         
    163132    def __str__( self ): 

  • project/trunk/test/model/TestModelLocator.py

    r23 r24  
    2525    def setUp( self ): 
    2626        self.instance = pyxoo.model.ModelLocator.getInstance() 
     27        self.instance.release() 
    2728        self.m1 = pyxoo.model.AbstractModel() 
    2829        self.m2 = pyxoo.model.AbstractModel() 
    …… 
    3839 
    3940    def testRegisterModel( self ): 
    40         self.instance.registerModel( "m1", self.m1 ) 
    41         self.assertRaises( TypeError, self.instance.registerModel, "mX", self.otherObject ) 
     41        self.instance.register( "m1", self.m1 ) 
     42        self.assertRaises( TypeError, self.instance.register, "mX", self.otherObject ) 
    4243        self.assertTrue( self.instance.isRegistered( "m1" ) ) 
    4344         
    4445    def testRegisterModelWithPlugin( self ): 
    4546        pluginA, pluginB = pyxoo.plugin.AbstractPlugin(), pyxoo.plugin.AbstractPlugin() 
    46         self.assertTrue( pyxoo.model.ModelLocator.getInstance( pluginA ).registerModel( "v1", self.m1 ) ) 
    47         self.assertFalse( pyxoo.model.ModelLocator.getInstance( pluginA ).registerModel( "v1", self.m1 ) ) 
    48         self.assertTrue( pyxoo.model.ModelLocator.getInstance( pluginB ).registerModel( "v1", self.m1 ) ) 
    49         self.assertFalse( pyxoo.model.ModelLocator.getInstance( pluginB ).registerModel( "v1", self.m1 ) ) 
     47        pyxoo.model.ModelLocator.getInstance( pluginA ).register( "v1", self.m1 ) 
     48        self.assertRaises( pyxoo.exceptions.IllegalArgumentException, pyxoo.model.ModelLocator.getInstance( pluginA ).register, "v1", self.m1 ) 
     49        pyxoo.model.ModelLocator.getInstance( pluginB ).register( "v1", self.m1 ) 
     50        self.assertRaises( pyxoo.exceptions.IllegalArgumentException, pyxoo.model.ModelLocator.getInstance( pluginB ).register, "v1", self.m1 ) 
    5051         
    5152    def testUnregisterModel( self ): 
    52         self.instance.registerModel( "m1", self.m1 ) 
    53         self.instance.registerModel( "m2", self.m2 ) 
     53        self.instance.register( "m1", self.m1 ) 
     54        self.instance.register( "m2", self.m2 ) 
    5455        self.assertTrue( self.instance.isRegistered( "m1" ) ) 
    5556        self.assertTrue( self.instance.isRegistered( "m2" ) ) 
    56         self.instance.unregisterModel( "m1" ) 
     57        self.instance.unregister( "m1" ) 
    5758        self.assertFalse( self.instance.isRegistered( "m1" ) ) 
    5859        self.assertTrue( self.instance.isRegistered( "m2" ) ) 
    5960         
    6061    def testLocate( self ):         
    61         self.instance.registerModel( "m1", self.m1 ) 
    62         self.instance.registerModel( "m2", self.m2 ) 
     62        self.instance.register( "m1", self.m1 ) 
     63        self.instance.register( "m2", self.m2 ) 
    6364        self.assertEquals( self.m1, self.instance.locate( "m1" ) ) 
    6465        self.assertEquals( self.m2, self.instance.locate( "m2" ) ) 
    65         self.instance.unregisterModel( "m1" ) 
    66         self.assertEquals( None, self.instance.locate( "m1" ) )   
     66        self.instance.unregister( "m1" ) 
     67        self.assertRaises( pyxoo.exceptions.NoSuchElementException, self.instance.locate, "m1" )   
    6768         

  • project/trunk/test/utils/TestInterface.py

    r21 r24  
    152152        self.assertTrue( isinstance( event, IEvent ) ) 
    153153        self.assertTrue( issubclass( MyEvent, IEvent ) ) 
     154        self.assertFalse( isinstance( self, MyEvent ) ) 
    154155         
    155156         

  • project/trunk/test/view/TestViewLocator.py

    r23 r24  
    2424    def setUp( self ): 
    2525        self.instance = pyxoo.view.ViewLocator.getInstance() 
     26        self.instance.release() 
    2627        self.view = pyxoo.view.AbstractView() 
    2728        class A:pass 
    …… 
    3738                         
    3839    def testRegisterView( self ): 
    39         self.assertTrue(self.instance.registerView( "aKey", self.view )) 
    40         self.assertFalse(self.instance.registerView( "aKey", self.view )) 
    41         self.assertRaises( TypeError, self.instance.registerView, "aSecondKey", self.otherObject ) 
     40        self.instance.register( "aKey", self.view ) 
     41        self.assertRaises( pyxoo.exceptions.IllegalArgumentException, self.instance.register, "aKey", self.view ) 
     42        self.assertRaises( TypeError, self.instance.register, "aSecondKey", self.otherObject ) 
    4243        self.assertTrue( self.instance.isRegistered( "aKey" ) ) 
    4344         
    4445    def testResgisterViewWithPlugin( self ): 
    4546        pluginA, pluginB = pyxoo.plugin.AbstractPlugin(), pyxoo.plugin.AbstractPlugin() 
    46         self.assertTrue( pyxoo.view.ViewLocator.getInstance( pluginA ).registerView( "v1", self.view ) ) 
    47         self.assertFalse( pyxoo.view.ViewLocator.getInstance( pluginA ).registerView( "v1", self.view ) ) 
    48         self.assertTrue( pyxoo.view.ViewLocator.getInstance( pluginB ).registerView( "v1", self.view ) ) 
    49         self.assertFalse( pyxoo.view.ViewLocator.getInstance( pluginB ).registerView( "v1", self.view ) ) 
     47        pyxoo.view.ViewLocator.getInstance( pluginA ).register( "v1", self.view ) 
     48        self.assertRaises( pyxoo.exceptions.IllegalArgumentException, pyxoo.view.ViewLocator.getInstance( pluginA ).register, "v1", self.view ) 
     49        pyxoo.view.ViewLocator.getInstance( pluginB ).register( "v1", self.view ) 
     50        self.assertRaises( pyxoo.exceptions.IllegalArgumentException, pyxoo.view.ViewLocator.getInstance( pluginB ).register, "v1", self.view ) 
    5051         
    5152    def testUnregisterView( self ): 
    52         self.instance.registerView( "v1", self.view ) 
    53         self.instance.registerView( "v2", pyxoo.view.AbstractView() ) 
     53        self.instance.register( "v1", self.view ) 
     54        self.instance.register( "v2", pyxoo.view.AbstractView() ) 
    5455        self.assertTrue( self.instance.isRegistered( "v1" ) ) 
    5556        self.assertTrue( self.instance.isRegistered( "v2" ) ) 
    56         self.instance.unregisterView( "v1" ) 
     57        self.instance.unregister( "v1" ) 
    5758        self.assertFalse( self.instance.isRegistered( "v1" ) ) 
    5859        self.assertTrue( self.instance.isRegistered( "v2" ) ) 
    5960         
    6061    def testLocate( self ):         
    61         self.instance.registerView( "v1", self.view ) 
     62        self.instance.register( "v1", self.view ) 
    6263        v2 = pyxoo.view.AbstractView() 
    63         self.instance.registerView( "v2", v2 ) 
     64        self.instance.register( "v2", v2 ) 
    6465        self.assertEquals( self.view, self.instance.locate( "v1" ) ) 
    6566        self.assertEquals( v2, self.instance.locate( "v2" ) ) 
    66         self.instance.unregisterView( "v1" ) 
    67         self.assertEquals( None, self.instance.locate( "v1" ) )         
     67        self.instance.unregister( "v1" ) 
     68        self.assertRaises( pyxoo.exceptions.NoSuchElementException, self.instance.locate, "v1" )