Move all C++ stuff to the new generators

python/dune/perftool/generation/__init__.py

@@ -2,4 +2,4 @@ from __future__ import absolute_import
 
 # TODO I am not sure about whether to collect these here or not.
 from dune.perftool.generation.cache import no_caching, generator_factory, retrieve_cache_items, delete_cache_items, delete_cache
-from dune.perftool.generation.generators import *
+from dune.perftool.generation.cpp import *

python/dune/perftool/generation/generators.py → python/dune/perftool/generation/cpp.py

@@ -9,19 +9,47 @@ from dune.perftool.cgen.clazz import AccessModifier
 symbol = generator_factory(item_tags=("symbol",))
 
 
-def include_file(include, filetag="operator"):
+def include_file(include, filetag=None):
+    assert filetag
     from cgen import Include
     gen = generator_factory(on_store=lambda i: Include(i), item_tags=(filetag, "include"), no_deco=True)
     return gen(include)
 
 
-# TODO this should perhaps already take into account a potential construction of the base class object
-def base_class(baseclass, classtag=None, access=AccessModifier.PUBLIC):
+def preamble(tag):
+    return generator_factory(item_tags=(tag, "preamble"), counted=True)
+
+
+def initializer_list(obj, params, classtag=None):
     assert classtag
+    gen = generator_factory(item_tags=(classtag, "initializer"), counted=True, cache_key_generator=lambda *a: a[0])
+    return "{}({})".format(obj, ", ".join(params))
+
+
+def base_class(baseclass, classtag=None, access=AccessModifier.PUBLIC, construction=[]):
+    assert classtag
+
     from dune.perftool.cgen.clazz import BaseClass
     gen = generator_factory(item_tags=("baseclass", classtag), on_store=lambda n: BaseClass(n, inheritance=access), counted=True, no_deco=True)
+
+    if construction:
+        initializer_list(baseclass, construction, classtag=classtag)
+
     return gen(baseclass)
 
 
-def preamble(tag):
-    return generator_factory(item_tags=(tag, "preamble"), counted=True)
+def class_member(classtag=None, access=AccessModifier.PRIVATE):
+    assert classtag
+    from cgen import Value
+    from dune.perftool.cgen.clazz import ClassMember
+
+    return generator_factory(item_tags=(classtag, "member"), on_store=lambda t, n: ClassMember(Value(_type, name), access=access), counted=True, cache_key_generator=lambda t, n: n)
+
+
+def constructor_parameter(_type, name, classtag=None, constructortag=None):
+    assert classtag
+    assert constructortag
+    from cgen import Value
+
+    gen = generator_factory(item_tags=(classtag, constructortag, "constructor", "parameter"), counted=True, no_deco=True)
+    return gen(Value(_type, name))

python/dune/perftool/generation/loopy.py

+""" The loopy specific generators """
\ No newline at end of file

python/dune/perftool/pdelab/__init__.py

 """ The pdelab specific parts of the code generation process """
 
 # Define the generators that are used throughout all pdelab specific code generations.
-from dune.perftool.generation import symbol
+from dune.perftool.generation import symbol, generator_factory
 from dune.perftool.loopy.transformer import quadrature_iname
 from loopy import CInstruction
 

python/dune/perftool/pdelab/localoperator.py

 from __future__ import absolute_import
 
 from dune.perftool.options import get_option
-from dune.perftool.generation import include_file, base_class, symbol, generator_factory
+from dune.perftool.generation import include_file, base_class, symbol, initializer_list, class_member, constructor_parameter
 from dune.perftool.cgen.clazz import BaseClass, ClassMember
 
 from pytools import memoize
 
 
-@generator_factory(item_tags=("initializer", "operator"), counted=True, cache_key_generator=lambda *a: a[0])
-def initializer_list(obj, params):
-    return "{}({})".format(obj, ", ".join(params))
+@class_member("operator")
+def define_initree(name):
+    include_file('dune/common/parametertree.hh', filetag="operatorfile")
+    constructor_parameter("const Dune::ParameterTree&", "iniParams", classtag="operator", constructortag="iniconstructor")
+    initializer_list("_iniParams", ["iniParams"])
 
-
-@generator_factory(item_tags=("operator", "member"), counted=True, cache_key_generator=lambda t, n: n)
-def define_private_member(_type, name):
-    from cgen import Value
-    from dune.perftool.cgen.clazz import ClassMember, AccessModifier
-    return ClassMember(Value(_type, name), access=AccessModifier.PRIVATE)
-
-
-@generator_factory(item_tags=("operator", "constructor_param"), counted=True)
-def constructor_parameter(_type, name):
-    from cgen import Value
-    return Value(_type, name)
-
-
-@symbol
-def name_initree_constructor():
-    include_file('dune/common/parametertree.hh', filetag="operator")
-    constructor_parameter("const Dune::ParameterTree&", "iniParams")
-    return "iniParams"
+    return "const Dune::ParameterTree&", "_iniParams"
 
 
 @symbol
 def name_initree_member():
-    include_file('dune/common/parametertree.hh', filetag="operator")
-    define_private_member("const Dune::ParameterTree&", "_iniParams")
-    in_constructor = name_initree_constructor()
-    initializer_list("_iniParams", [in_constructor])
+    define_initree("_iniParams")
     return "_iniParams"
 
 
@@ -166,11 +147,11 @@ def generate_localoperator_kernels(form):
     delete_cache()
 
     # Manage includes and base classes that we always need
-    include_file('dune/pdelab/gridfunctionspace/gridfunctionspaceutilities.hh', filetag="operator")
-    include_file('dune/pdelab/localoperator/idefault.hh', filetag="operator")
-    include_file('dune/pdelab/localoperator/flags.hh', filetag="operator")
-    include_file('dune/pdelab/localoperator/pattern.hh', filetag="operator")
-    include_file('dune/geometry/quadraturerules.hh', filetag="operator")
+    include_file('dune/pdelab/gridfunctionspace/gridfunctionspaceutilities.hh', filetag="operatorfile")
+    include_file('dune/pdelab/localoperator/idefault.hh', filetag="operatorfile")
+    include_file('dune/pdelab/localoperator/flags.hh', filetag="operatorfile")
+    include_file('dune/pdelab/localoperator/pattern.hh', filetag="operatorfile")
+    include_file('dune/geometry/quadraturerules.hh', filetag="operatorfile")
 
     base_class('Dune::PDELab::LocalOperatorDefaultFlags', classtag="operator")
 
@@ -185,7 +166,7 @@ def generate_localoperator_kernels(form):
     # Generate the necessary jacobian methods
     from dune.perftool.options import get_option
     if get_option("numerical_jacobian"):
-        include_file("dune/pdelab/localoperator/defaultimp.hh", filetag="operator")
+        include_file("dune/pdelab/localoperator/defaultimp.hh", filetag="operatorfile")
     else:
         from ufl import derivative
         from ufl.algorithms import expand_derivatives
@@ -214,4 +195,4 @@ def generate_localoperator_file(kernels):
 
     # TODO take the name of this thing from the UFL file
     lop = cgen_class_from_cache("operator", members=operator_methods)
-    generate_file(get_option("operator_file"), "operator", [lop])
+    generate_file(get_option("operator_file"), "operatorfile", [lop])