Changeset 3057:1ad9c0acc32a in livinglogic.python.xist

Show
Ignore:
Timestamp:
12/18/07 16:34:42 (12 years ago)
Author:
Walter Doerwald <walter@…>
Branch:
default
Message:

Unify Pool and ChainedPool?. Pool subclasses misc.Pool now.

Files:
2 modified

Legend:

Unmodified
Added
Removed
  • src/ll/xist/xsc.py

    r3055 r3057  
    33903390### 
    33913391 
    3392 class Pool(object): 
     3392class Pool(misc.Pool): 
    33933393    def __init__(self, *objects): 
    33943394        self._elementsbyxmlname = weakref.WeakValueDictionary() 
     
    34043404        self._attrsbypyname = weakref.WeakValueDictionary() 
    34053405        self._attrs = weakref.WeakValueDictionary() 
    3406         for object in objects: 
    3407             self.register(object) 
     3406        misc.Pool.__init__(self, *objects) 
    34083407 
    34093408    def register(self, object): 
     
    34513450                    self.register(attr) 
    34523451        elif isinstance(object, types.ModuleType): 
     3452            super(Pool, self).register(object) 
    34533453            for (key, value) in object.__dict__.iteritems(): 
    34543454                if isinstance(value, type): # This avoids recursive module registration 
    34553455                    self.register(value) 
    3456                 try: 
    3457                     self._attrs[key] = value 
    3458                 except TypeError: 
    3459                     pass 
    34603456        elif isinstance(object, dict): 
     3457            super(Pool, self).register(object) 
    34613458            for (key, value) in object.iteritems(): 
    34623459                if isinstance(value, type): # This avoids recursive module registration 
    34633460                    self.register(value) 
    3464                 try: 
    3465                     self._attrs[key] = value 
    3466                 except TypeError: 
    3467                     pass 
     3461        elif isinstance(object, Pool): 
     3462            super(Pool, self).register(object) 
    34683463 
    34693464    def __enter__(self): 
     
    34783473        Return an iterator for all registered element classes. 
    34793474        """ 
    3480         return self._elementsbypyname.itervalues() 
     3475        return self._elementsbypyname.itervalues() # FIXME: this ignores bases 
    34813476 
    34823477    def elementclass(self, name, xmlns): 
     
    34993494            except KeyError: 
    35003495                pass 
     3496        for base in self.bases: 
     3497            return base.elementclass(name, xmlns) 
    35013498        raise IllegalElementError(name, xmlns, False) 
    35023499 
     
    35203517            except KeyError: 
    35213518                pass 
     3519        for base in self.bases: 
     3520            return base.elementclass_xml(name, xmlns) 
    35223521        raise IllegalElementError(name, xmlns, True) 
    35233522 
     
    35413540        with the Python name <arg>name</arg> and the namespace <arg>xmlns</arg>? 
    35423541        """ 
    3543         return (name, nsname(xmlns)) in self._elementsbypyname 
     3542        return (name, nsname(xmlns)) in self._elementsbypyname or any(base.haselement(name, xmlns) for base in self.bases) 
    35443543 
    35453544    def haselement_xml(self, name, xmlns): 
     
    35483547        with the &xml; name <arg>name</arg> and the namespace <arg>xmlns</arg>? 
    35493548        """ 
    3550         return (name, nsname(xmlns)) in self._elementsbyxmlname 
     3549        return (name, nsname(xmlns)) in self._elementsbyxmlname or any(base.haselement_xml(name, xmlns) for base in self.bases) 
    35513550 
    35523551    def procinsts(self): 
     
    35543553        Return an iterator for all registered processing instruction classes. 
    35553554        """ 
    3556         return self._procinstsbypyname.itervalues() 
     3555        return self._procinstsbypyname.itervalues() # FIXME: this ignores bases 
    35573556 
    35583557    def procinstclass(self, name): 
     
    35653564            return self._procinstsbypyname[name] 
    35663565        except KeyError: 
     3566            for base in self.bases: 
     3567                return base.procinstclass(name, xmlns) 
    35673568            raise IllegalProcInstError(name, False) 
    35683569 
     
    35763577            return self._procinstsbyxmlname[name] 
    35773578        except KeyError: 
     3579            for base in self.bases: 
     3580                return base.procinstclass_xml(name, xmlns) 
    35783581            raise IllegalProcInstError(name, True) 
    35793582 
     
    35973600        PI with the Python name <arg>name</arg>? 
    35983601        """ 
    3599         return name in self._procinstsbypyname 
     3602        return name in self._procinstsbypyname or any(base.hasprocinst(name) for base in self.bases) 
    36003603 
    36013604    def hasprocinst_xml(self, name): 
     
    36043607        PI with the &xml; name <arg>name</arg>? 
    36053608        """ 
    3606         return name in self._procinstsbyxmlname 
     3609        return name in self._procinstsbyxmlname or any(base.hasprocinst_xml(name) for base in self.bases) 
    36073610 
    36083611    def entities(self): 
     
    36103613        Return an iterator for all registered entity classes. 
    36113614        """ 
    3612         return self._entitiesbypyname.itervalues() 
     3615        return self._entitiesbypyname.itervalues() # FIXME: this ignores bases 
    36133616 
    36143617    def entityclass(self, name): 
     
    36213624            return self._entitiesbypyname[name] 
    36223625        except KeyError: 
     3626            for base in self.bases: 
     3627                return base.entityclass(name) 
    36233628            raise IllegalEntityError(name, False) 
    36243629 
     
    36323637            return self._entitiesbyxmlname[name] 
    36333638        except KeyError: 
     3639            for base in self.bases: 
     3640                return base.entityclass_xml(name) 
    36343641            raise IllegalEntityError(name, True) 
    36353642 
     
    36533660        Python name <arg>name</arg>? 
    36543661        """ 
    3655         return name in self._entitiesbypyname 
     3662        return name in self._entitiesbypyname or any(base.hasentity(name) for base in self.bases) 
    36563663 
    36573664    def hasentity_xml(self, name): 
     
    36603667        &xml; name <arg>name</arg>? 
    36613668        """ 
    3662         return name in self._entitiesbyxmlname 
     3669        return name in self._entitiesbyxmlname or any(base.hasentity_xml(name) for base in self.bases) 
    36633670 
    36643671    def charrefs(self): 
     
    36663673        Return an iterator for all character entity classes. 
    36673674        """ 
    3668         return self._charrefsbypyname.itervalues() 
     3675        return self._charrefsbypyname.itervalues() # FIXME: this ignores bases 
    36693676 
    36703677    def charrefclass(self, name): 
     
    36803687            return self._charrefsbypyname[name] 
    36813688        except KeyError: 
     3689            for base in self.bases: 
     3690                return base.charrefclass(name) 
    36823691            raise IllegalEntityError(name, False) 
    36833692 
     
    36943703            return self._charrefsbyxmlname[name] 
    36953704        except KeyError: 
     3705            for base in self.bases: 
     3706                return base.charrefclass_xml(name) 
    36963707            raise IllegalEntityError(name, True) 
    36973708 
     
    37163727        """ 
    37173728        if isinstance(name, (int, long)): 
    3718             return name in self._charrefsbycodepoint 
     3729            has = name in self._charrefsbycodepoint 
    37193730        else: 
    3720             return name in self._charrefsbypyname 
     3731            has = name in self._charrefsbypyname 
     3732        return has or any(base.hascharref(name) for base in self.bases) 
    37213733 
    37223734    def hascharref_xml(self, name): 
     
    37263738        """ 
    37273739        if isinstance(name, (int, long)): 
    3728             return name in self._charrefsbycodepoint 
     3740            has = name in self._charrefsbycodepoint 
    37293741        else: 
    3730             return name in self._charrefsbypyname 
     3742            has = name in self._charrefsbypyname 
     3743        return has or any(base.hascharref_xml(name) for base in self.bases) 
    37313744 
    37323745    def attrclass(self, name, xmlns): 
     
    37443757            except KeyError: 
    37453758                pass 
     3759        for base in self.bases: 
     3760            return base.attrclass(name, xmlns) 
    37463761        raise IllegalAttrError(name, xmlns, False) 
    37473762 
     
    37603775            except KeyError: 
    37613776                pass 
     3777        for base in self.bases: 
     3778            return base.attrclass_xml(name, xmlns) 
    37623779        raise IllegalAttrError(name, xmlns, True) 
    37633780 
     
    37783795            return self._attrs[key] 
    37793796        except KeyError: 
     3797            for base in self.bases: 
     3798                return getattr(base, key) 
    37803799            raise AttributeError(key) 
    37813800 
     
    37843803        Return a copy of <self/>. 
    37853804        """ 
    3786         copy = self.__class__() 
     3805        copy = Pool.clone(self) 
    37873806        copy._elementsbyxmlname = self._elementsbyxmlname.copy() 
    37883807        copy._elementsbypyname = self._elementsbypyname.copy() 
     
    37963815        copy._attrsbyxmlname = self._attrsbyxmlname.copy() 
    37973816        copy._attrsbypyname = self._attrsbypyname.copy() 
    3798         copy._attrs = self._attrs.copy() 
    37993817        return copy 
    38003818 
    38013819 
    3802 class ChainedPool(Pool): 
    3803     """ 
    3804     <par>Class pool for <pyref class="Element">element</pyref>, 
    3805     <pyref class="ProcInst">procinst</pyref>, <pyref class="Entity">entity</pyref>, 
    3806     <pyref class="CharRef">charref</pyref> and <pyref class="Attr">attribute</pyref> classes.</par> 
    3807  
    3808     <par>This is used by the parser to map names to classes.</par> 
    3809     """ 
    3810     def __init__(self, *objects): 
    3811         """ 
    3812         <par>Create a new pool. All objects in <arg>objects</arg> will be passed 
    3813         to the <method>register</method> method.</par> 
    3814         """ 
    3815         self.bases = [] 
    3816         Pool.__init__(self, *objects) 
    3817  
    3818     def register(self, object): 
    3819         """ 
    3820         <par>Register <arg>object</arg> in the pool. In addition to the types 
    3821         supported by the base class' <pyref class="Pool"><method>register</method></pyref> 
    3822         method, the following arguments are supported:</par> 
    3823         <ulist> 
    3824         <item>A <class>Pool</class> object (this pool object will be added to the 
    3825         base pools. If a class isn't found in <self/> the search continues in this 
    3826         base pool;</item> 
    3827         <item><lit>True</lit>, which adds the current default pool to the base pools.</item> 
    3828         </ulist> 
    3829         """ 
    3830         Pool.register(self, object) 
    3831         if object is True: 
    3832             self.bases.append(getpoolstack()[-1]) 
    3833         elif isinstance(object, Pool): 
    3834             self.bases.append(object) 
    3835         elif isinstance(object, types.ModuleType) and hasattr(object, "xmlbases"): 
    3836             for module in object.xmlbases: 
    3837                 self.register(ChainedPool(module)) 
    3838  
    3839     def elementclass(self, name, xmlns): 
    3840         try: 
    3841             return Pool.elementclass(self, name, xmlns) 
    3842         except IllegalElementError: 
    3843             for base in self.bases: 
    3844                 return base.elementclass(name, xmlns) 
    3845             raise 
    3846  
    3847     def elementclass_xml(self, name, xmlns): 
    3848         try: 
    3849             return Pool.elementclass_xml(self, name, xmlns) 
    3850         except IllegalElementError: 
    3851             for base in self.bases: 
    3852                 return base.elementclass_xml(name, xmlns) 
    3853             raise 
    3854  
    3855     def haselement(self, name, xmlns): 
    3856         return Pool.haselement(self, name, xmlns) or any(base.haselement(name, xmlns) for base in self.bases) 
    3857  
    3858     def haselement_xml(self, name, xmlns): 
    3859         return Pool.haselement_xml(self, name, xmlns) or any(base.haselement_xml(name, xmlns) for base in self.bases) 
    3860  
    3861     def procinstclass(self, name): 
    3862         try: 
    3863             return Pool.procinstclass(self, name) 
    3864         except IllegalProcInstError: 
    3865             for base in self.bases: 
    3866                 return base.procinstclass(name, xmlns) 
    3867             raise 
    3868  
    3869     def procinstclass_xml(self, name): 
    3870         try: 
    3871             return Pool.procinstclass_xml(self, name) 
    3872         except IllegalProcInstError: 
    3873             for base in self.bases: 
    3874                 return base.procinstclass_xml(name, xmlns) 
    3875             raise 
    3876  
    3877     def hasprocinst(self, name): 
    3878         return Pool.hasprocinst(self, name) or any(base.hasprocinst(name) for base in self.bases) 
    3879  
    3880     def hasprocinst_xml(self, name): 
    3881         return Pool.hasprocinst_xml(self, name) or any(base.hasprocinst_xml(name) for base in self.bases) 
    3882  
    3883     def entityclass(self, name): 
    3884         try: 
    3885             return Pool.entityclass(self, name) 
    3886         except IllegalEntityError: 
    3887             for base in self.bases: 
    3888                 return base.entityclass(name) 
    3889             raise 
    3890  
    3891     def entityclass_xml(self, name): 
    3892         try: 
    3893             return Pool.entityclass_xml(self, name) 
    3894         except IllegalEntityError: 
    3895             for base in self.bases: 
    3896                 return base.entityclass_xml(name) 
    3897             raise 
    3898  
    3899     def hasentity(self, name): 
    3900         return Pool.hasentity(self, name) or any(base.hasentity(name) for base in self.bases) 
    3901  
    3902     def hasentity_xml(self, name): 
    3903         return Pool.hasentity_xml(self, name) or any(base.hasentity_xml(name) for base in self.bases) 
    3904  
    3905     def charrefclass(self, name): 
    3906         try: 
    3907             return Pool.charrefclass(self, name) 
    3908         except IllegalEntityError: 
    3909             for base in self.bases: 
    3910                 return base.charrefclass(name) 
    3911             raise 
    3912  
    3913     def charrefclass_xml(self, name): 
    3914         try: 
    3915             return Pool.charrefclass_xml(self, name) 
    3916         except IllegalEntityError: 
    3917             for base in self.bases: 
    3918                 return base.charrefclass_xml(name) 
    3919             raise 
    3920  
    3921     def hascharref(self, name): 
    3922         return Pool.hascharref(self, name) or any(base.hascharref(name) for base in self.bases) 
    3923  
    3924     def hascharref_xml(self, name): 
    3925         return Pool.hascharref_xml(self, name) or any(base.hascharref_xml(name) for base in self.bases) 
    3926  
    3927     def attrclass(self, name, xmlns): 
    3928         try: 
    3929             return Pool.attrclass(self, name, xmlns) 
    3930         except IllegalAttrError: 
    3931             for base in self.bases: 
    3932                 return base.attrclass(name, xmlns) 
    3933             raise 
    3934  
    3935     def attrclass_xml(self, name, xmlns): 
    3936         try: 
    3937             return Pool.attrclass_xml(self, name, xmlns) 
    3938         except IllegalAttrError: 
    3939             for base in self.bases: 
    3940                 return base.attrclass_xml(name, xmlns) 
    3941             raise 
    3942  
    3943     def __getattr__(self, key): 
    3944         try: 
    3945             return Pool.__getattr__(self, key) 
    3946         except AttributeError: 
    3947             for base in self.bases: 
    3948                 return getattr(base, key) 
    3949             raise 
    3950  
    3951     def clone(self): 
    3952         """ 
    3953         Return a copy of <self/>. 
    3954         """ 
    3955         copy = Pool.clone(self) 
    3956         copy.bases = self.bases[:] 
    3957         return copy 
    3958  
    3959  
    39603820# Default class pool 
    3961 defaultpool = ChainedPool() 
     3821defaultpool = Pool() 
    39623822 
    39633823 
  • test/test_pool.py

    r3035 r3057  
    228228            xmlns = "nix" 
    229229 
    230     with xsc.ChainedPool(r1) as r2: 
     230    with xsc.Pool(r1) as r2: 
    231231        class foo2(xsc.Element): 
    232232            xmlname = "foo" 
     
    249249            xmlns = "nix" 
    250250 
    251         with xsc.ChainedPool(True) as r2: 
     251        with xsc.Pool(True) as r2: 
    252252            class bar(xsc.Element): 
    253253                xmlns = "nix"