Draft: Refactor UFL types using UFLType

Author: nbouziani

ufl/core/expr.py

@@ -20,11 +20,66 @@
 # Modified by Massimiliano Leoni, 2016
 
 from ufl.log import error
+# from ufl.core.ufl_type import UFLType
+from ufl.utils.formatting import camel2underscore
+
+
+class UFLType(type):
+    """Base class for all UFL types.
+
+    Equip UFL types with properties such as:
+
+    - `_ufl_typecode_`: The integer typecode is a contiguous index different for each
+                        type. This is used for fast lookup into e.g. multifunction handler tables.
+
+    - `_ufl_num_typecodes_`: A global counter of the number of typecodes assigned.
+
+    """
+
+    def __init__(cls, name, bases, attrs):
+        # Determine integer typecode by incrementally counting all types
+        cls._ufl_typecode_ = UFLType._ufl_num_typecodes_
+        UFLType._ufl_num_typecodes_ += 1
+
+        UFLType._ufl_all_classes_.append(cls)
+
+        # Determine handler name by a mapping from "TypeName" to "type_name"
+        cls._ufl_handler_name_ = camel2underscore(cls.__name__)
+        UFLType._ufl_all_handler_names_.add(cls._ufl_handler_name_)
+
+        # Append space for counting object creation and destriction of
+        # this this type.
+        UFLType._ufl_obj_init_counts_.append(0)
+        UFLType._ufl_obj_del_counts_.append(0)
+
+    # A global counter of the number of typecodes assigned.
+    _ufl_num_typecodes_ = 0
+
+    # A global array of all Expr subclasses, indexed by typecode
+    _ufl_all_classes_ = []
+
+    # A global set of all handler names added
+    _ufl_all_handler_names_ = set()
+
+    # A global array of the number of initialized objects for each
+    # typecode
+    _ufl_obj_init_counts_ = []
+
+    # A global array of the number of deleted objects for each
+    # typecode
+    _ufl_obj_del_counts_ = []
+
+    # Type trait: If the type is abstract.  An abstract class cannot
+    # be instantiated and does not need all properties specified.
+    _ufl_is_abstract_ = True
+
+    # Type trait: If the type is terminal.
+    _ufl_is_terminal_ = None
 
 
 # --- The base object for all UFL expression tree nodes ---
 
-class Expr(object):
+class Expr(object, metaclass=UFLType):
     """Base class for all UFL expression types.
 
     *Instance properties*
@@ -128,22 +183,10 @@ def __init__(self):
     # implement for this type in a multifunction.
     _ufl_handler_name_ = "expr"
 
-    # The integer typecode, a contiguous index different for each
-    # type.  This is used for fast lookup into e.g. multifunction
-    # handler tables.
-    _ufl_typecode_ = 0
-
     # Number of operands, "varying" for some types, or None if not
     # applicable for abstract types.
     _ufl_num_ops_ = None
 
-    # Type trait: If the type is abstract.  An abstract class cannot
-    # be instantiated and does not need all properties specified.
-    _ufl_is_abstract_ = True
-
-    # Type trait: If the type is terminal.
-    _ufl_is_terminal_ = None
-
     # Type trait: If the type is a literal.
     _ufl_is_literal_ = None
 
@@ -227,15 +270,6 @@ def __init__(self):
 
     # --- Global variables for collecting all types ---
 
-    # A global counter of the number of typecodes assigned
-    _ufl_num_typecodes_ = 1
-
-    # A global set of all handler names added
-    _ufl_all_handler_names_ = set()
-
-    # A global array of all Expr subclasses, indexed by typecode
-    _ufl_all_classes_ = []
-
     # A global dict mapping language_operator_name to the type it
     # produces
     _ufl_language_operators_ = {}
@@ -245,14 +279,6 @@ def __init__(self):
 
     # --- Mechanism for profiling object creation and deletion ---
 
-    # A global array of the number of initialized objects for each
-    # typecode
-    _ufl_obj_init_counts_ = [0]
-
-    # A global array of the number of deleted objects for each
-    # typecode
-    _ufl_obj_del_counts_ = [0]
-
     # Backup of default init and del
     _ufl_regular__init__ = __init__
 
@@ -425,8 +451,6 @@ def geometric_dimension(self):
 # Initializing traits here because Expr is not defined in the class
 # declaration
 Expr._ufl_class_ = Expr
-Expr._ufl_all_handler_names_.add(Expr)
-Expr._ufl_all_classes_.append(Expr)
 
 
 def ufl_err_str(expr):

ufl/core/ufl_type.py

@@ -10,7 +10,6 @@
 
 from ufl.core.expr import Expr
 from ufl.core.compute_expr_hash import compute_expr_hash
-from ufl.utils.formatting import camel2underscore
 
 
 # Make UFL type coercion available under the as_ufl name
@@ -214,9 +213,6 @@ def _inherited_ufl_index_dimensions(self):
 
 def update_global_expr_attributes(cls):
     "Update global ``Expr`` attributes, mainly by adding *cls* to global collections of ufl types."
-    Expr._ufl_all_classes_.append(cls)
-    Expr._ufl_all_handler_names_.add(cls._ufl_handler_name_)
-
     if cls._ufl_is_terminal_modifier_:
         Expr._ufl_terminal_modifiers_.append(cls)
 
@@ -228,11 +224,6 @@ def update_global_expr_attributes(cls):
         cls._ufl_function_.__func__.__doc__ = cls.__doc__
         Expr._ufl_language_operators_[cls._ufl_handler_name_] = cls._ufl_function_
 
-    # Append space for counting object creation and destriction of
-    # this this type.
-    Expr._ufl_obj_init_counts_.append(0)
-    Expr._ufl_obj_del_counts_.append(0)
-
 
 def ufl_type(is_abstract=False,
              is_terminal=None,
@@ -264,13 +255,6 @@ def ufl_type(is_abstract=False,
     """
 
     def _ufl_type_decorator_(cls):
-        # Determine integer typecode by oncrementally counting all types
-        typecode = Expr._ufl_num_typecodes_
-        Expr._ufl_num_typecodes_ += 1
-
-        # Determine handler name by a mapping from "TypeName" to "type_name"
-        handler_name = camel2underscore(cls.__name__)
-
         # is_scalar implies is_index_free
         if is_scalar:
             _is_index_free = True
@@ -279,8 +263,6 @@ def _ufl_type_decorator_(cls):
 
         # Store type traits
         cls._ufl_class_ = cls
-        set_trait(cls, "handler_name", handler_name, inherit=False)
-        set_trait(cls, "typecode", typecode, inherit=False)
         set_trait(cls, "is_abstract", is_abstract, inherit=False)
 
         set_trait(cls, "is_terminal", is_terminal, inherit=True)

ufl/form.py

@@ -19,7 +19,7 @@
 from ufl.integral import Integral
 from ufl.checks import is_scalar_constant_expression
 from ufl.equation import Equation
-from ufl.core.expr import Expr
+from ufl.core.expr import Expr, UFLType
 from ufl.core.expr import ufl_err_str
 from ufl.constantvalue import Zero
 
@@ -69,7 +69,7 @@ def _sorted_integrals(integrals):
     return tuple(all_integrals)  # integrals_dict
 
 
-class BaseForm(object):
+class BaseForm(object, metaclass=UFLType):
     """Description of an object containing arguments"""
 
     # Slots is kept empty to enable multiple inheritance with other classes.