Changeset 3169:50a8c3be9bcd in livinglogic.python.xist

Show
Ignore:
Timestamp:
01/23/08 22:09:32 (12 years ago)
Author:
Walter Doerwald <walter@…>
Branch:
default
Message:

Fix handling of multiple bases and use dict instead of WeakValueDictionary? in Pool. Add clear() method.

Files:
1 modified

Legend:

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

    r3144 r3169  
    27942794        if "model" in dict and isinstance(dict["model"], bool): 
    27952795            from ll.xist import sims 
    2796             if dict["model"]: 
    2797                 dict["model"] = sims.Any() 
    2798             else: 
    2799                 dict["model"] = sims.Empty() 
     2796            dict["model"] = sims.Any() if dict["model"] else sims.Empty() 
    28002797        _patchclassnames(dict, name) 
    28012798        self = super(_Element_Meta, cls).__new__(cls, name, bases, dict) 
     
    34033400class Pool(misc.Pool): 
    34043401    def __init__(self, *objects): 
    3405         self._elementsbyxmlname = weakref.WeakValueDictionary() 
    3406         self._elementsbypyname = weakref.WeakValueDictionary() 
    3407         self._procinstsbyxmlname = weakref.WeakValueDictionary() 
    3408         self._procinstsbypyname = weakref.WeakValueDictionary() 
    3409         self._entitiesbyxmlname = weakref.WeakValueDictionary() 
    3410         self._entitiesbypyname = weakref.WeakValueDictionary() 
    3411         self._charrefsbyxmlname = weakref.WeakValueDictionary() 
    3412         self._charrefsbypyname = weakref.WeakValueDictionary() 
    3413         self._charrefsbycodepoint = weakref.WeakValueDictionary() 
    3414         self._attrsbyxmlname = weakref.WeakValueDictionary() 
    3415         self._attrsbypyname = weakref.WeakValueDictionary() 
    3416         self._attrs = weakref.WeakValueDictionary() 
     3402        self._elementsbyxmlname = {} 
     3403        self._elementsbypyname = {} 
     3404        self._procinstsbyxmlname = {} 
     3405        self._procinstsbypyname = {} 
     3406        self._entitiesbyxmlname = {} 
     3407        self._entitiesbypyname = {} 
     3408        self._charrefsbyxmlname = {} 
     3409        self._charrefsbypyname = {} 
     3410        self._charrefsbycodepoint = {} 
     3411        self._attrsbyxmlname = {} 
     3412        self._attrsbypyname = {} 
    34173413        misc.Pool.__init__(self, *objects) 
    34183414 
     
    34653461                if isinstance(value, type): # This avoids recursive module registration 
    34663462                    self.register(value) 
    3467                 elif key == "xmlns" and type(value) is str: 
    3468                     self.xmlns = value 
    34693463        elif isinstance(object, dict): 
    34703464            super(Pool, self).register(object) 
     
    35083502                pass 
    35093503        for base in self.bases: 
    3510             return base.elementclass(name, xmlns) 
     3504            try: 
     3505                return base.elementclass(name, xmlns) 
     3506            except IllegalElementError: 
     3507                pass 
    35113508        raise IllegalElementError(name, xmlns, False) 
    35123509 
     
    35313528                pass 
    35323529        for base in self.bases: 
    3533             return base.elementclass_xml(name, xmlns) 
     3530            try: 
     3531                return base.elementclass_xml(name, xmlns) 
     3532            except IllegalElementError: 
     3533                pass 
    35343534        raise IllegalElementError(name, xmlns, True) 
    35353535 
     
    35783578        except KeyError: 
    35793579            for base in self.bases: 
    3580                 return base.procinstclass(name, xmlns) 
     3580                try: 
     3581                    return base.procinstclass(name) 
     3582                except IllegalProcInstError: 
     3583                    pass 
    35813584            raise IllegalProcInstError(name, False) 
    35823585 
     
    35913594        except KeyError: 
    35923595            for base in self.bases: 
    3593                 return base.procinstclass_xml(name, xmlns) 
     3596                try: 
     3597                    return base.procinstclass_xml(name) 
     3598                except IllegalProcInstError: 
     3599                    pass 
    35943600            raise IllegalProcInstError(name, True) 
    35953601 
     
    36383644        except KeyError: 
    36393645            for base in self.bases: 
    3640                 return base.entityclass(name) 
     3646                try: 
     3647                    return base.entityclass(name) 
     3648                except IllegalEntityError: 
     3649                    pass 
    36413650            raise IllegalEntityError(name, False) 
    36423651 
     
    36513660        except KeyError: 
    36523661            for base in self.bases: 
    3653                 return base.entityclass_xml(name) 
     3662                try: 
     3663                    return base.entityclass_xml(name) 
     3664                except IllegalEntityError: 
     3665                    pass 
    36543666            raise IllegalEntityError(name, True) 
    36553667 
     
    37013713        except KeyError: 
    37023714            for base in self.bases: 
    3703                 return base.charrefclass(name) 
     3715                try: 
     3716                    return base.charrefclass(name) 
     3717                except IllegalEntityError: 
     3718                    pass 
    37043719            raise IllegalEntityError(name, False) 
    37053720 
     
    37173732        except KeyError: 
    37183733            for base in self.bases: 
    3719                 return base.charrefclass_xml(name) 
     3734                try: 
     3735                    return base.charrefclass_xml(name) 
     3736                except IllegalEntityError: 
     3737                    pass 
    37203738            raise IllegalEntityError(name, True) 
    37213739 
     
    37713789                pass 
    37723790        for base in self.bases: 
    3773             return base.attrclass(name, xmlns) 
     3791            try: 
     3792                return base.attrclass(name, xmlns) 
     3793            except IllegalAttrError: 
     3794                pass 
    37743795        raise IllegalAttrError(name, xmlns, False) 
    37753796 
     
    37893810                pass 
    37903811        for base in self.bases: 
    3791             return base.attrclass_xml(name, xmlns) 
     3812            try: 
     3813                return base.attrclass_xml(name, xmlns) 
     3814            except IllegalAttrError: 
     3815                pass 
    37923816        raise IllegalAttrError(name, xmlns, True) 
    37933817 
     
    38113835                return getattr(base, key) 
    38123836            raise AttributeError(key) 
     3837 
     3838    def clear(self): 
     3839        self._elementsbyxmlname.clear() 
     3840        self._elementsbypyname.clear() 
     3841        self._procinstsbyxmlname.clear() 
     3842        self._procinstsbypyname.clear() 
     3843        self._entitiesbyxmlname.clear() 
     3844        self._entitiesbypyname.clear() 
     3845        self._charrefsbyxmlname.clear() 
     3846        self._charrefsbypyname.clear() 
     3847        self._charrefsbycodepoint.clear() 
     3848        self._attrsbyxmlname.clear() 
     3849        self._attrsbypyname.clear() 
     3850        misc.Pool.clear() 
    38133851 
    38143852    def clone(self):