Changeset 3057:1ad9c0acc32a in livinglogic.python.xist

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:

• src/ll/xist/xsc.py (modified) (28 diffs)
• test/test_pool.py (modified) (2 diffs)

src/ll/xist/xsc.py

@@ -3390 +3390 @@
 ###
 
-class Pool(object):
+class Pool(misc.Pool):
     def __init__(self, *objects):
         self._elementsbyxmlname = weakref.WeakValueDictionary()
@@ -3404 +3404 @@
         self._attrsbypyname = weakref.WeakValueDictionary()
         self._attrs = weakref.WeakValueDictionary()
-        for object in objects:
-            self.register(object)
+        misc.Pool.__init__(self, *objects)
 
     def register(self, object):
@@ -3451 +3450 @@
                     self.register(attr)
         elif isinstance(object, types.ModuleType):
+            super(Pool, self).register(object)
             for (key, value) in object.__dict__.iteritems():
                 if isinstance(value, type): # This avoids recursive module registration
                     self.register(value)
-                try:
-                    self._attrs[key] = value
-                except TypeError:
-                    pass
         elif isinstance(object, dict):
+            super(Pool, self).register(object)
             for (key, value) in object.iteritems():
                 if isinstance(value, type): # This avoids recursive module registration
                     self.register(value)
-                try:
-                    self._attrs[key] = value
-                except TypeError:
-                    pass
+        elif isinstance(object, Pool):
+            super(Pool, self).register(object)
 
     def __enter__(self):
@@ -3478 +3473 @@
         Return an iterator for all registered element classes.
         """
-        return self._elementsbypyname.itervalues()
+        return self._elementsbypyname.itervalues() # FIXME: this ignores bases
 
     def elementclass(self, name, xmlns):
@@ -3499 +3494 @@
             except KeyError:
                 pass
+        for base in self.bases:
+            return base.elementclass(name, xmlns)
         raise IllegalElementError(name, xmlns, False)
 
@@ -3520 +3517 @@
             except KeyError:
                 pass
+        for base in self.bases:
+            return base.elementclass_xml(name, xmlns)
         raise IllegalElementError(name, xmlns, True)
 
@@ -3541 +3540 @@
         with the Python name <arg>name</arg> and the namespace <arg>xmlns</arg>?
         """
-        return (name, nsname(xmlns)) in self._elementsbypyname
+        return (name, nsname(xmlns)) in self._elementsbypyname or any(base.haselement(name, xmlns) for base in self.bases)
 
     def haselement_xml(self, name, xmlns):
@@ -3548 +3547 @@
         with the &xml; name <arg>name</arg> and the namespace <arg>xmlns</arg>?
         """
-        return (name, nsname(xmlns)) in self._elementsbyxmlname
+        return (name, nsname(xmlns)) in self._elementsbyxmlname or any(base.haselement_xml(name, xmlns) for base in self.bases)
 
     def procinsts(self):
@@ -3554 +3553 @@
         Return an iterator for all registered processing instruction classes.
         """
-        return self._procinstsbypyname.itervalues()
+        return self._procinstsbypyname.itervalues() # FIXME: this ignores bases
 
     def procinstclass(self, name):
@@ -3565 +3564 @@
             return self._procinstsbypyname[name]
         except KeyError:
+            for base in self.bases:
+                return base.procinstclass(name, xmlns)
             raise IllegalProcInstError(name, False)
 
@@ -3576 +3577 @@
             return self._procinstsbyxmlname[name]
         except KeyError:
+            for base in self.bases:
+                return base.procinstclass_xml(name, xmlns)
             raise IllegalProcInstError(name, True)
 
@@ -3597 +3600 @@
         PI with the Python name <arg>name</arg>?
         """
-        return name in self._procinstsbypyname
+        return name in self._procinstsbypyname or any(base.hasprocinst(name) for base in self.bases)
 
     def hasprocinst_xml(self, name):
@@ -3604 +3607 @@
         PI with the &xml; name <arg>name</arg>?
         """
-        return name in self._procinstsbyxmlname
+        return name in self._procinstsbyxmlname or any(base.hasprocinst_xml(name) for base in self.bases)
 
     def entities(self):
@@ -3610 +3613 @@
         Return an iterator for all registered entity classes.
         """
-        return self._entitiesbypyname.itervalues()
+        return self._entitiesbypyname.itervalues() # FIXME: this ignores bases
 
     def entityclass(self, name):
@@ -3621 +3624 @@
             return self._entitiesbypyname[name]
         except KeyError:
+            for base in self.bases:
+                return base.entityclass(name)
             raise IllegalEntityError(name, False)
 
@@ -3632 +3637 @@
             return self._entitiesbyxmlname[name]
         except KeyError:
+            for base in self.bases:
+                return base.entityclass_xml(name)
             raise IllegalEntityError(name, True)
 
@@ -3653 +3660 @@
         Python name <arg>name</arg>?
         """
-        return name in self._entitiesbypyname
+        return name in self._entitiesbypyname or any(base.hasentity(name) for base in self.bases)
 
     def hasentity_xml(self, name):
@@ -3660 +3667 @@
         &xml; name <arg>name</arg>?
         """
-        return name in self._entitiesbyxmlname
+        return name in self._entitiesbyxmlname or any(base.hasentity_xml(name) for base in self.bases)
 
     def charrefs(self):
@@ -3666 +3673 @@
         Return an iterator for all character entity classes.
         """
-        return self._charrefsbypyname.itervalues()
+        return self._charrefsbypyname.itervalues() # FIXME: this ignores bases
 
     def charrefclass(self, name):
@@ -3680 +3687 @@
             return self._charrefsbypyname[name]
         except KeyError:
+            for base in self.bases:
+                return base.charrefclass(name)
             raise IllegalEntityError(name, False)
 
@@ -3694 +3703 @@
             return self._charrefsbyxmlname[name]
         except KeyError:
+            for base in self.bases:
+                return base.charrefclass_xml(name)
             raise IllegalEntityError(name, True)
 
@@ -3716 +3727 @@
         """
         if isinstance(name, (int, long)):
-            return name in self._charrefsbycodepoint
+            has = name in self._charrefsbycodepoint
         else:
-            return name in self._charrefsbypyname
+            has = name in self._charrefsbypyname
+        return has or any(base.hascharref(name) for base in self.bases)
 
     def hascharref_xml(self, name):
@@ -3726 +3738 @@
         """
         if isinstance(name, (int, long)):
-            return name in self._charrefsbycodepoint
+            has = name in self._charrefsbycodepoint
         else:
-            return name in self._charrefsbypyname
+            has = name in self._charrefsbypyname
+        return has or any(base.hascharref_xml(name) for base in self.bases)
 
     def attrclass(self, name, xmlns):
@@ -3744 +3757 @@
             except KeyError:
                 pass
+        for base in self.bases:
+            return base.attrclass(name, xmlns)
         raise IllegalAttrError(name, xmlns, False)
 
@@ -3760 +3775 @@
             except KeyError:
                 pass
+        for base in self.bases:
+            return base.attrclass_xml(name, xmlns)
         raise IllegalAttrError(name, xmlns, True)
 
@@ -3778 +3795 @@
             return self._attrs[key]
         except KeyError:
+            for base in self.bases:
+                return getattr(base, key)
             raise AttributeError(key)
 
@@ -3784 +3803 @@
         Return a copy of <self/>.
         """
-        copy = self.__class__()
+        copy = Pool.clone(self)
         copy._elementsbyxmlname = self._elementsbyxmlname.copy()
         copy._elementsbypyname = self._elementsbypyname.copy()
@@ -3796 +3815 @@
         copy._attrsbyxmlname = self._attrsbyxmlname.copy()
         copy._attrsbypyname = self._attrsbypyname.copy()
-        copy._attrs = self._attrs.copy()
         return copy
 
 
-class ChainedPool(Pool):
-    """
-    <par>Class pool for <pyref class="Element">element</pyref>,
-    <pyref class="ProcInst">procinst</pyref>, <pyref class="Entity">entity</pyref>,
-    <pyref class="CharRef">charref</pyref> and <pyref class="Attr">attribute</pyref> classes.</par>
-
-    <par>This is used by the parser to map names to classes.</par>
-    """
-    def __init__(self, *objects):
-        """
-        <par>Create a new pool. All objects in <arg>objects</arg> will be passed
-        to the <method>register</method> method.</par>
-        """
-        self.bases = []
-        Pool.__init__(self, *objects)
-
-    def register(self, object):
-        """
-        <par>Register <arg>object</arg> in the pool. In addition to the types
-        supported by the base class' <pyref class="Pool"><method>register</method></pyref>
-        method, the following arguments are supported:</par>
-        <ulist>
-        <item>A <class>Pool</class> object (this pool object will be added to the
-        base pools. If a class isn't found in <self/> the search continues in this
-        base pool;</item>
-        <item><lit>True</lit>, which adds the current default pool to the base pools.</item>
-        </ulist>
-        """
-        Pool.register(self, object)
-        if object is True:
-            self.bases.append(getpoolstack()[-1])
-        elif isinstance(object, Pool):
-            self.bases.append(object)
-        elif isinstance(object, types.ModuleType) and hasattr(object, "xmlbases"):
-            for module in object.xmlbases:
-                self.register(ChainedPool(module))
-
-    def elementclass(self, name, xmlns):
-        try:
-            return Pool.elementclass(self, name, xmlns)
-        except IllegalElementError:
-            for base in self.bases:
-                return base.elementclass(name, xmlns)
-            raise
-
-    def elementclass_xml(self, name, xmlns):
-        try:
-            return Pool.elementclass_xml(self, name, xmlns)
-        except IllegalElementError:
-            for base in self.bases:
-                return base.elementclass_xml(name, xmlns)
-            raise
-
-    def haselement(self, name, xmlns):
-        return Pool.haselement(self, name, xmlns) or any(base.haselement(name, xmlns) for base in self.bases)
-
-    def haselement_xml(self, name, xmlns):
-        return Pool.haselement_xml(self, name, xmlns) or any(base.haselement_xml(name, xmlns) for base in self.bases)
-
-    def procinstclass(self, name):
-        try:
-            return Pool.procinstclass(self, name)
-        except IllegalProcInstError:
-            for base in self.bases:
-                return base.procinstclass(name, xmlns)
-            raise
-
-    def procinstclass_xml(self, name):
-        try:
-            return Pool.procinstclass_xml(self, name)
-        except IllegalProcInstError:
-            for base in self.bases:
-                return base.procinstclass_xml(name, xmlns)
-            raise
-
-    def hasprocinst(self, name):
-        return Pool.hasprocinst(self, name) or any(base.hasprocinst(name) for base in self.bases)
-
-    def hasprocinst_xml(self, name):
-        return Pool.hasprocinst_xml(self, name) or any(base.hasprocinst_xml(name) for base in self.bases)
-
-    def entityclass(self, name):
-        try:
-            return Pool.entityclass(self, name)
-        except IllegalEntityError:
-            for base in self.bases:
-                return base.entityclass(name)
-            raise
-
-    def entityclass_xml(self, name):
-        try:
-            return Pool.entityclass_xml(self, name)
-        except IllegalEntityError:
-            for base in self.bases:
-                return base.entityclass_xml(name)
-            raise
-
-    def hasentity(self, name):
-        return Pool.hasentity(self, name) or any(base.hasentity(name) for base in self.bases)
-
-    def hasentity_xml(self, name):
-        return Pool.hasentity_xml(self, name) or any(base.hasentity_xml(name) for base in self.bases)
-
-    def charrefclass(self, name):
-        try:
-            return Pool.charrefclass(self, name)
-        except IllegalEntityError:
-            for base in self.bases:
-                return base.charrefclass(name)
-            raise
-
-    def charrefclass_xml(self, name):
-        try:
-            return Pool.charrefclass_xml(self, name)
-        except IllegalEntityError:
-            for base in self.bases:
-                return base.charrefclass_xml(name)
-            raise
-
-    def hascharref(self, name):
-        return Pool.hascharref(self, name) or any(base.hascharref(name) for base in self.bases)
-
-    def hascharref_xml(self, name):
-        return Pool.hascharref_xml(self, name) or any(base.hascharref_xml(name) for base in self.bases)
-
-    def attrclass(self, name, xmlns):
-        try:
-            return Pool.attrclass(self, name, xmlns)
-        except IllegalAttrError:
-            for base in self.bases:
-                return base.attrclass(name, xmlns)
-            raise
-
-    def attrclass_xml(self, name, xmlns):
-        try:
-            return Pool.attrclass_xml(self, name, xmlns)
-        except IllegalAttrError:
-            for base in self.bases:
-                return base.attrclass_xml(name, xmlns)
-            raise
-
-    def __getattr__(self, key):
-        try:
-            return Pool.__getattr__(self, key)
-        except AttributeError:
-            for base in self.bases:
-                return getattr(base, key)
-            raise
-
-    def clone(self):
-        """
-        Return a copy of <self/>.
-        """
-        copy = Pool.clone(self)
-        copy.bases = self.bases[:]
-        return copy
-
-
 # Default class pool
-defaultpool = ChainedPool()
+defaultpool = Pool()
 
 

test/test_pool.py

@@ -228 +228 @@
             xmlns = "nix"
 
-    with xsc.ChainedPool(r1) as r2:
+    with xsc.Pool(r1) as r2:
         class foo2(xsc.Element):
             xmlname = "foo"
@@ -249 +249 @@
             xmlns = "nix"
 
-        with xsc.ChainedPool(True) as r2:
+        with xsc.Pool(True) as r2:
             class bar(xsc.Element):
                 xmlns = "nix"