Use boost::variant to hold QuadKey in SubGridL2FunctionalAssembler.

dune/fufem/assemblers/localassemblers/subgridl2functionalassembler.hh

@@ -3,6 +3,7 @@
 #ifndef SUBGRID_L2_FUNCTIONAL_ASSEMBLER_HH
 #define SUBGRID_L2_FUNCTIONAL_ASSEMBLER_HH
 
+#include <boost/variant.hpp>
 
 #include <dune/common/function.hh>
 #include <dune/common/fvector.hh>
@@ -55,10 +56,9 @@ class SubgridL2FunctionalAssembler :
          */
         template<typename B, typename C, std::enable_if<std::is_base_of<HostGridFunction, BasisGridFunction<B,C>>::value_type>>
         SubgridL2FunctionalAssembler(const BasisGridFunction<B, C>& f, const GridType& grid) :
-            functionQuadKey_(0),
+            quadKeySource_(f),
             grid_(grid),
-            f_(f),
-            hostBasisGridFunctionInfo_(&f)
+            f_(f)
         {}
 
         /** \brief constructor
@@ -76,10 +76,9 @@ class SubgridL2FunctionalAssembler :
          * \param fQuadKey A QuadratureRuleKey that specifies how to integrate f
          */
          SubgridL2FunctionalAssembler(const HostGridFunction& f, const GridType& grid, const QuadratureRuleKey& fQuadKey) :
-            functionQuadKey_(&fQuadKey),
+            quadKeySource_(fQuadKey),
             grid_(grid),
-            f_(f),
-            hostBasisGridFunctionInfo_(0)
+            f_(f)
         {
             if(dynamic_cast<const HostBasisGridFunctionInfo*>(&f))
                 Dune::dwarn << "Overriding HostBasis Quadrature rule." << std::endl;
@@ -106,10 +105,7 @@ class SubgridL2FunctionalAssembler :
                 // get quadrature rule
                 QuadratureRuleKey quadKey(tFE);
                 quadKey.setGeometryType(element.type());
-                if (hostBasisGridFunctionInfo_)
-                  quadKey = quadKey.product(hostBasisGridFunctionInfo_->quadratureRuleKey(*baseHostElement));
-                else
-                  quadKey = quadKey.product(*functionQuadKey_);
+                quadKey = quadKey.product(boost::apply_visitor( QuadKeySourceVisitor(*baseHostElement), quadKeySource_ ) );
                 const Dune::template QuadratureRule<double, dim>& quad = QuadratureRuleCache<double, dim>::rule(quadKey);
 
                 // loop over quadrature points
@@ -152,10 +148,7 @@ class SubgridL2FunctionalAssembler :
                         // get quadrature rule
                         QuadratureRuleKey quadKey(tFE);
                         quadKey.setGeometryType(hostElement.type());
-                        if (hostBasisGridFunctionInfo_)
-                          quadKey = quadKey.product(hostBasisGridFunctionInfo_->quadratureRuleKey(hostElement));
-                        else
-                          quadKey = quadKey.product(*functionQuadKey_);
+                        quadKey = quadKey.product(boost::apply_visitor( QuadKeySourceVisitor(hostElement), quadKeySource_ ) );
                         const Dune::template QuadratureRule<double, dim>& quad = QuadratureRuleCache<double, dim>::rule(quadKey);
 
 
@@ -190,10 +183,21 @@ class SubgridL2FunctionalAssembler :
         }
 
     private:
-        const QuadratureRuleKey* functionQuadKey_;
+        using QuadKeySource = boost::variant<const QuadratureRuleKey&, const HostBasisGridFunctionInfo&>;
+        struct QuadKeySourceVisitor : public boost::static_visitor<const QuadratureRuleKey&>
+        {
+          QuadKeySourceVisitor(const HostElement& e) : e_(e) {}
+
+          const QuadratureRuleKey& operator()(const QuadratureRuleKey& q) const { return q; }
+          const QuadratureRuleKey& operator()(const HostBasisGridFunctionInfo& info) const { return info.quadratureRuleKey(e_); }
+
+        private:
+          const HostElement& e_;
+        };
+
+        const QuadKeySource quadKeySource_;
         const GridType& grid_;
         const HostGridFunction& f_;
-        const HostBasisGridFunctionInfo* hostBasisGridFunctionInfo_;
 };
 
 #endif