Feature/parameterizedobjectfactory

the idea is to have a generic factory which can be extended by the user at run time and maps a key (usually an std::string) to a constructor-call (usually taking a Dune::ParameterTree).

We want something like a plugin-system, to instantiate implementations of an abstract interface. Usually a factory can only create a hard-coded list of objects. The proposed ParameterizedObjectFactory different modules (or the user) can register implementations of the interface, without modifying the factory code.

Example:

using V = Dune::BlockVector<Dune::FieldVector<double,2>>;
using M = Dune::BCRSMatrix<Dune::FieldMatrix<double,2,2>>;

using PreconditionerFactory = 
  Dune::ParameterizedObjectFactory<Dune::Preconditioner<V,V>(const M&, const Dune::ParameterTree&)>;

PreconditionerFactory::define<Dune::SeqGS<M,V,V>>("Gauss-Seidel");

dune/common/test/parameterizedobjecttest.cc

@@ -37,23 +37,50 @@ DefineImplementation(InterfaceB, Bis, int, std::string);
     assert(#T == F.create(#T,##PARAM)->info())
 
 
+struct AImp : public InterfaceA
+{
+    AImp(std::string s) :
+        s_(s)
+    {}
+
+    AImp(const AImp& other) :
+        s_("copied")
+    {}
+
+    virtual std::string info()
+    {
+        return s_;
+    }
+    std::string s_;
+};
+
 int main()
 {
     // int as parameter
     Dune::ParameterizedObjectFactory<std::unique_ptr<InterfaceA>, std::string, int> FactoryA;
     FactoryA.define<Ai>("Ai");
     FactoryA.define<Bi>("Bi");
+    FactoryA.define<Ax>("Ax", [](int i) { return Dune::Std::make_unique<Ax>(); });
     CheckInstance(FactoryA, Ai, 0);
     CheckInstance(FactoryA, Bi, 1);
+    CheckInstance(FactoryA, Ax, 1);
 
     // default constructor
     Dune::ParameterizedObjectFactory<std::shared_ptr<InterfaceA>, std::string> FactoryAd;
     FactoryAd.define<Ax>("Ax");
     FactoryAd.define<Bx>("Bx");
+    FactoryAd.define<Ai>("Ai", []() { return std::make_shared<Ai>(0); });
+    AImp aimp("onStack");
+    FactoryAd.define<AImp>("AImp", [&]() { return Dune::stackobject_to_shared_ptr<AImp>(aimp); });
+    FactoryAd.define("AImp2", Dune::stackobject_to_shared_ptr<AImp>(aimp));
+    FactoryAd.define("AImp3", std::make_shared<AImp>("shared"));
     Dune::ParameterTree param;
     CheckInstance(FactoryAd, Ax);
     CheckInstance(FactoryAd, Bx);
     CheckInstance(FactoryAd, Ai);
+    std::cout << FactoryAd.create("AImp")->info() << std::endl;
+    std::cout << FactoryAd.create("AImp2")->info() << std::endl;
+    std::cout << FactoryAd.create("AImp3")->info() << std::endl;
 
     // explicitly request the default constructor
     Dune::ParameterizedObjectFactory<std::unique_ptr<InterfaceA>, std::string> FactoryAx;