gras: simplfy factory w/ macros and namespace

2 files changed, 217 insertions, 85 deletions

diff --git a/include/gras/detail/factory.hpp b/include/gras/detail/factory.hpp
index ac4df6f..d1edf81 100644
--- a/include/gras/detail/factory.hpp
+++ b/include/gras/detail/factory.hpp
@@ -37,7 +37,7 @@ struct FactoryRegistryEntryImpl0 : FactoryRegistryEntry
 };
 
 template <typename ReturnType>
-void Factory::register_make(const std::string &name, ReturnType(*fcn)())
+void register_make(const std::string &name, ReturnType(*fcn)())
 {
     void *r = new FactoryRegistryEntryImpl0<ReturnType>(fcn);
     Factory::_register_make(name, r);
@@ -61,7 +61,7 @@ struct FactoryRegistryEntryImpl1 : FactoryRegistryEntry
 };
 
 template <typename ReturnType, typename A0>
-void Factory::register_make(const std::string &name, ReturnType(*fcn)(const A0 &))
+void register_make(const std::string &name, ReturnType(*fcn)(const A0 &))
 {
     void *r = new FactoryRegistryEntryImpl1<ReturnType, A0>(fcn);
     Factory::_register_make(name, r);
@@ -85,7 +85,7 @@ struct FactoryRegistryEntryImpl2 : FactoryRegistryEntry
 };
 
 template <typename ReturnType, typename A0, typename A1>
-void Factory::register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &))
+void register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &))
 {
     void *r = new FactoryRegistryEntryImpl2<ReturnType, A0, A1>(fcn);
     Factory::_register_make(name, r);
@@ -109,7 +109,7 @@ struct FactoryRegistryEntryImpl3 : FactoryRegistryEntry
 };
 
 template <typename ReturnType, typename A0, typename A1, typename A2>
-void Factory::register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &))
+void register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &))
 {
     void *r = new FactoryRegistryEntryImpl3<ReturnType, A0, A1, A2>(fcn);
     Factory::_register_make(name, r);
@@ -133,7 +133,7 @@ struct FactoryRegistryEntryImpl4 : FactoryRegistryEntry
 };
 
 template <typename ReturnType, typename A0, typename A1, typename A2, typename A3>
-void Factory::register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &, const A3 &))
+void register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &, const A3 &))
 {
     void *r = new FactoryRegistryEntryImpl4<ReturnType, A0, A1, A2, A3>(fcn);
     Factory::_register_make(name, r);
@@ -157,7 +157,7 @@ struct FactoryRegistryEntryImpl5 : FactoryRegistryEntry
 };
 
 template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4>
-void Factory::register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &))
+void register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &))
 {
     void *r = new FactoryRegistryEntryImpl5<ReturnType, A0, A1, A2, A3, A4>(fcn);
     Factory::_register_make(name, r);
@@ -181,7 +181,7 @@ struct FactoryRegistryEntryImpl6 : FactoryRegistryEntry
 };
 
 template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5>
-void Factory::register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &))
+void register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &))
 {
     void *r = new FactoryRegistryEntryImpl6<ReturnType, A0, A1, A2, A3, A4, A5>(fcn);
     Factory::_register_make(name, r);
@@ -205,7 +205,7 @@ struct FactoryRegistryEntryImpl7 : FactoryRegistryEntry
 };
 
 template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
-void Factory::register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &))
+void register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &))
 {
     void *r = new FactoryRegistryEntryImpl7<ReturnType, A0, A1, A2, A3, A4, A5, A6>(fcn);
     Factory::_register_make(name, r);
@@ -229,7 +229,7 @@ struct FactoryRegistryEntryImpl8 : FactoryRegistryEntry
 };
 
 template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
-void Factory::register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &))
+void register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &))
 {
     void *r = new FactoryRegistryEntryImpl8<ReturnType, A0, A1, A2, A3, A4, A5, A6, A7>(fcn);
     Factory::_register_make(name, r);
@@ -253,7 +253,7 @@ struct FactoryRegistryEntryImpl9 : FactoryRegistryEntry
 };
 
 template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
-void Factory::register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &, const A8 &))
+void register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &, const A8 &))
 {
     void *r = new FactoryRegistryEntryImpl9<ReturnType, A0, A1, A2, A3, A4, A5, A6, A7, A8>(fcn);
     Factory::_register_make(name, r);
@@ -277,7 +277,7 @@ struct FactoryRegistryEntryImpl10 : FactoryRegistryEntry
 };
 
 template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
-void Factory::register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &, const A8 &, const A9 &))
+void register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &, const A8 &, const A9 &))
 {
     void *r = new FactoryRegistryEntryImpl10<ReturnType, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>(fcn);
     Factory::_register_make(name, r);
@@ -287,14 +287,14 @@ void Factory::register_make(const std::string &name, ReturnType(*fcn)(const A0 &
  * Templated make implementations
  **********************************************************************/
 inline
-Element *Factory::make(const std::string &name)
+Element *make(const std::string &name)
 {
     PMCList args(0);
     return Factory::_handle_make(name, PMC_M(args));
 }
 
 template <typename A0>
-Element *Factory::make(const std::string &name, const A0 &a0)
+Element *make(const std::string &name, const A0 &a0)
 {
     PMCList args(1);
     args[0] = PMC_M(a0);
@@ -302,7 +302,7 @@ Element *Factory::make(const std::string &name, const A0 &a0)
 }
 
 template <typename A0, typename A1>
-Element *Factory::make(const std::string &name, const A0 &a0, const A1 &a1)
+Element *make(const std::string &name, const A0 &a0, const A1 &a1)
 {
     PMCList args(2);
     args[0] = PMC_M(a0);
@@ -311,7 +311,7 @@ Element *Factory::make(const std::string &name, const A0 &a0, const A1 &a1)
 }
 
 template <typename A0, typename A1, typename A2>
-Element *Factory::make(const std::string &name, const A0 &a0, const A1 &a1, const A2 &a2)
+Element *make(const std::string &name, const A0 &a0, const A1 &a1, const A2 &a2)
 {
     PMCList args(3);
     args[0] = PMC_M(a0);
@@ -321,7 +321,7 @@ Element *Factory::make(const std::string &name, const A0 &a0, const A1 &a1, cons
 }
 
 template <typename A0, typename A1, typename A2, typename A3>
-Element *Factory::make(const std::string &name, const A0 &a0, const A1 &a1, const A2 &a2, const A3 &a3)
+Element *make(const std::string &name, const A0 &a0, const A1 &a1, const A2 &a2, const A3 &a3)
 {
     PMCList args(4);
     args[0] = PMC_M(a0);
@@ -332,7 +332,7 @@ Element *Factory::make(const std::string &name, const A0 &a0, const A1 &a1, cons
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4>
-Element *Factory::make(const std::string &name, const A0 &a0, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4)
+Element *make(const std::string &name, const A0 &a0, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4)
 {
     PMCList args(5);
     args[0] = PMC_M(a0);
@@ -344,7 +344,7 @@ Element *Factory::make(const std::string &name, const A0 &a0, const A1 &a1, cons
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5>
-Element *Factory::make(const std::string &name, const A0 &a0, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5)
+Element *make(const std::string &name, const A0 &a0, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5)
 {
     PMCList args(6);
     args[0] = PMC_M(a0);
@@ -357,7 +357,7 @@ Element *Factory::make(const std::string &name, const A0 &a0, const A1 &a1, cons
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
-Element *Factory::make(const std::string &name, const A0 &a0, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6)
+Element *make(const std::string &name, const A0 &a0, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6)
 {
     PMCList args(7);
     args[0] = PMC_M(a0);
@@ -371,7 +371,7 @@ Element *Factory::make(const std::string &name, const A0 &a0, const A1 &a1, cons
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
-Element *Factory::make(const std::string &name, const A0 &a0, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7)
+Element *make(const std::string &name, const A0 &a0, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7)
 {
     PMCList args(8);
     args[0] = PMC_M(a0);
@@ -386,7 +386,7 @@ Element *Factory::make(const std::string &name, const A0 &a0, const A1 &a1, cons
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
-Element *Factory::make(const std::string &name, const A0 &a0, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8)
+Element *make(const std::string &name, const A0 &a0, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8)
 {
     PMCList args(9);
     args[0] = PMC_M(a0);
@@ -402,7 +402,7 @@ Element *Factory::make(const std::string &name, const A0 &a0, const A1 &a1, cons
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
-Element *Factory::make(const std::string &name, const A0 &a0, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8, const A9 &a9)
+Element *make(const std::string &name, const A0 &a0, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8, const A9 &a9)
 {
     PMCList args(10);
     args[0] = PMC_M(a0);
diff --git a/include/gras/factory.hpp b/include/gras/factory.hpp
index 13524a6..9600586 100644
--- a/include/gras/factory.hpp
+++ b/include/gras/factory.hpp
@@ -8,15 +8,6 @@
 #include <PMC/PMC.hpp>
 #include <string>
 
-/*!
- * Register a block's factory function:
- * Declare this macro at the global scope in a cpp file.
- * The block will register at static initialization time.
- */
-#define GRAS_REGISTER_FACTORY(name, fcn) \
-    GRAS_STATIC_BLOCK(fcn) \
-    {gras::Factory::register_make(name, &fcn);}
-
 namespace gras
 {
 
@@ -34,86 +25,227 @@ namespace gras
 struct GRAS_API Factory
 {
     /*******************************************************************
-     * Register API - don't look here, template magic, not helpful
+     * Private registration hooks
      ******************************************************************/
-    template <typename ReturnType>
-    static void register_make(const std::string &name, ReturnType(*fcn)());
+    static void _register_make(const std::string &, void *);
+    static Element *_handle_make(const std::string &, const PMCC &);
+};
 
-    template <typename ReturnType, typename A0>
-    static void register_make(const std::string &name, ReturnType(*fcn)(const A0 &));
+/***********************************************************************
+ * Register API - don't look here, template magic, not helpful
+ **********************************************************************/
+template <typename ReturnType>
+static void register_make(const std::string &name, ReturnType(*fcn)());
 
-    template <typename ReturnType, typename A0, typename A1>
-    static void register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &));
+template <typename ReturnType, typename A0>
+static void register_make(const std::string &name, ReturnType(*fcn)(const A0 &));
 
-    template <typename ReturnType, typename A0, typename A1, typename A2>
-    static void register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &));
+template <typename ReturnType, typename A0, typename A1>
+static void register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &));
 
-    template <typename ReturnType, typename A0, typename A1, typename A2, typename A3>
-    static void register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &, const A3 &));
+template <typename ReturnType, typename A0, typename A1, typename A2>
+static void register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &));
 
-    template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4>
-    static void register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &));
+template <typename ReturnType, typename A0, typename A1, typename A2, typename A3>
+static void register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &, const A3 &));
 
-    template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5>
-    static void register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &));
+template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4>
+static void register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &));
 
-    template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
-    static void register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &));
+template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5>
+static void register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &));
 
-    template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
-    static void register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &));
+template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
+static void register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &));
 
-    template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
-    static void register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &, const A8 &));
+template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
+static void register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &));
 
-    template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
-    static void register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &, const A8 &, const A9 &));
+template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
+static void register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &, const A8 &));
 
-    /*******************************************************************
-     * Make API - don't look here, template magic, not helpful
-     ******************************************************************/;
-    inline
-    static Element *make(const std::string &name);
+template <typename ReturnType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
+static void register_make(const std::string &name, ReturnType(*fcn)(const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &, const A8 &, const A9 &));
 
-    template <typename A0>
-    static Element *make(const std::string &name, const A0 &);
+/***********************************************************************
+ * Make API - don't look here, template magic, not helpful
+ **********************************************************************/
+inline
+static Element *make(const std::string &name);
 
-    template <typename A0, typename A1>
-    static Element *make(const std::string &name, const A0 &, const A1 &);
+template <typename A0>
+static Element *make(const std::string &name, const A0 &);
 
-    template <typename A0, typename A1, typename A2>
-    static Element *make(const std::string &name, const A0 &, const A1 &, const A2 &);
+template <typename A0, typename A1>
+static Element *make(const std::string &name, const A0 &, const A1 &);
 
-    template <typename A0, typename A1, typename A2, typename A3>
-    static Element *make(const std::string &name, const A0 &, const A1 &, const A2 &, const A3 &);
+template <typename A0, typename A1, typename A2>
+static Element *make(const std::string &name, const A0 &, const A1 &, const A2 &);
 
-    template <typename A0, typename A1, typename A2, typename A3, typename A4>
-    static Element *make(const std::string &name, const A0 &, const A1 &, const A2 &, const A3 &, const A4 &);
+template <typename A0, typename A1, typename A2, typename A3>
+static Element *make(const std::string &name, const A0 &, const A1 &, const A2 &, const A3 &);
 
-    template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5>
-    static Element *make(const std::string &name, const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &);
+template <typename A0, typename A1, typename A2, typename A3, typename A4>
+static Element *make(const std::string &name, const A0 &, const A1 &, const A2 &, const A3 &, const A4 &);
 
-    template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
-    static Element *make(const std::string &name, const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &);
+template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5>
+static Element *make(const std::string &name, const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &);
 
-    template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
-    static Element *make(const std::string &name, const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &);
+template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
+static Element *make(const std::string &name, const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &);
 
-    template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
-    static Element *make(const std::string &name, const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &, const A8 &);
+template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
+static Element *make(const std::string &name, const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &);
 
-    template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
-    static Element *make(const std::string &name, const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &, const A8 &, const A9 &);
+template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
+static Element *make(const std::string &name, const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &, const A8 &);
 
-    /*******************************************************************
-     * Private registration hooks
-     ******************************************************************/
-    static void _register_make(const std::string &, void *);
-    static Element *_handle_make(const std::string &, const PMCC &);
-};
+template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
+static Element *make(const std::string &name, const A0 &, const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &, const A7 &, const A8 &, const A9 &);
 
 }
 
+/*!
+ * Register a block's factory function:
+ * Declare this macro at the global scope in a cpp file.
+ * The block will register at static initialization time.
+ */
+#define GRAS_REGISTER_FACTORY(name, fcn) \
+    GRAS_STATIC_BLOCK(fcn) \
+    {gras::register_make(name, &fcn);}
+
+/*!
+ * Register a block's constructor into the factory:
+ * The arguments to this macro must be the types of each constructor argument.
+ * Example: GRAS_REGISTER_FACTORY2("/proj/my_block", MyBlock, std::string, size_t)
+ * Declare this macro at the global scope in a cpp file.
+ * The block will register at static initialization time.
+ */
+#define GRAS_REGISTER_FACTORY0(name, type) \
+    static gras::Element *make_ ## type() \
+    { return new type(); } \
+    GRAS_REGISTER_FACTORY(name, make_##type)
+
+/*!
+ * Register a block's constructor into the factory:
+ * The arguments to this macro must be the types of each constructor argument.
+ * Example: GRAS_REGISTER_FACTORY2("/proj/my_block", MyBlock, std::string, size_t)
+ * Declare this macro at the global scope in a cpp file.
+ * The block will register at static initialization time.
+ */
+#define GRAS_REGISTER_FACTORY1(name, type, A0) \
+    static gras::Element *make_ ## type(const A0 &a0) \
+    { return new type(a0); } \
+    GRAS_REGISTER_FACTORY(name, make_##type)
+
+/*!
+ * Register a block's constructor into the factory:
+ * The arguments to this macro must be the types of each constructor argument.
+ * Example: GRAS_REGISTER_FACTORY2("/proj/my_block", MyBlock, std::string, size_t)
+ * Declare this macro at the global scope in a cpp file.
+ * The block will register at static initialization time.
+ */
+#define GRAS_REGISTER_FACTORY2(name, type, A0, A1) \
+    static gras::Element *make_ ## type(const A0 &a0, const A1 &a1) \
+    { return new type(a0, a1); } \
+    GRAS_REGISTER_FACTORY(name, make_##type)
+
+/*!
+ * Register a block's constructor into the factory:
+ * The arguments to this macro must be the types of each constructor argument.
+ * Example: GRAS_REGISTER_FACTORY2("/proj/my_block", MyBlock, std::string, size_t)
+ * Declare this macro at the global scope in a cpp file.
+ * The block will register at static initialization time.
+ */
+#define GRAS_REGISTER_FACTORY3(name, type, A0, A1, A2) \
+    static gras::Element *make_ ## type(const A0 &a0, const A1 &a1, const A2 &a2) \
+    { return new type(a0, a1, a2); } \
+    GRAS_REGISTER_FACTORY(name, make_##type)
+
+/*!
+ * Register a block's constructor into the factory:
+ * The arguments to this macro must be the types of each constructor argument.
+ * Example: GRAS_REGISTER_FACTORY2("/proj/my_block", MyBlock, std::string, size_t)
+ * Declare this macro at the global scope in a cpp file.
+ * The block will register at static initialization time.
+ */
+#define GRAS_REGISTER_FACTORY4(name, type, A0, A1, A2, A3) \
+    static gras::Element *make_ ## type(const A0 &a0, const A1 &a1, const A2 &a2, const A3 &a3) \
+    { return new type(a0, a1, a2, a3); } \
+    GRAS_REGISTER_FACTORY(name, make_##type)
+
+/*!
+ * Register a block's constructor into the factory:
+ * The arguments to this macro must be the types of each constructor argument.
+ * Example: GRAS_REGISTER_FACTORY2("/proj/my_block", MyBlock, std::string, size_t)
+ * Declare this macro at the global scope in a cpp file.
+ * The block will register at static initialization time.
+ */
+#define GRAS_REGISTER_FACTORY5(name, type, A0, A1, A2, A3, A4) \
+    static gras::Element *make_ ## type(const A0 &a0, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4) \
+    { return new type(a0, a1, a2, a3, a4); } \
+    GRAS_REGISTER_FACTORY(name, make_##type)
+
+/*!
+ * Register a block's constructor into the factory:
+ * The arguments to this macro must be the types of each constructor argument.
+ * Example: GRAS_REGISTER_FACTORY2("/proj/my_block", MyBlock, std::string, size_t)
+ * Declare this macro at the global scope in a cpp file.
+ * The block will register at static initialization time.
+ */
+#define GRAS_REGISTER_FACTORY6(name, type, A0, A1, A2, A3, A4, A5) \
+    static gras::Element *make_ ## type(const A0 &a0, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5) \
+    { return new type(a0, a1, a2, a3, a4, a5); } \
+    GRAS_REGISTER_FACTORY(name, make_##type)
+
+/*!
+ * Register a block's constructor into the factory:
+ * The arguments to this macro must be the types of each constructor argument.
+ * Example: GRAS_REGISTER_FACTORY2("/proj/my_block", MyBlock, std::string, size_t)
+ * Declare this macro at the global scope in a cpp file.
+ * The block will register at static initialization time.
+ */
+#define GRAS_REGISTER_FACTORY7(name, type, A0, A1, A2, A3, A4, A5, A6) \
+    static gras::Element *make_ ## type(const A0 &a0, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6) \
+    { return new type(a0, a1, a2, a3, a4, a5, a6); } \
+    GRAS_REGISTER_FACTORY(name, make_##type)
+
+/*!
+ * Register a block's constructor into the factory:
+ * The arguments to this macro must be the types of each constructor argument.
+ * Example: GRAS_REGISTER_FACTORY2("/proj/my_block", MyBlock, std::string, size_t)
+ * Declare this macro at the global scope in a cpp file.
+ * The block will register at static initialization time.
+ */
+#define GRAS_REGISTER_FACTORY8(name, type, A0, A1, A2, A3, A4, A5, A6, A7) \
+    static gras::Element *make_ ## type(const A0 &a0, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7) \
+    { return new type(a0, a1, a2, a3, a4, a5, a6, a7); } \
+    GRAS_REGISTER_FACTORY(name, make_##type)
+
+/*!
+ * Register a block's constructor into the factory:
+ * The arguments to this macro must be the types of each constructor argument.
+ * Example: GRAS_REGISTER_FACTORY2("/proj/my_block", MyBlock, std::string, size_t)
+ * Declare this macro at the global scope in a cpp file.
+ * The block will register at static initialization time.
+ */
+#define GRAS_REGISTER_FACTORY9(name, type, A0, A1, A2, A3, A4, A5, A6, A7, A8) \
+    static gras::Element *make_ ## type(const A0 &a0, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8) \
+    { return new type(a0, a1, a2, a3, a4, a5, a6, a7, a8); } \
+    GRAS_REGISTER_FACTORY(name, make_##type)
+
+/*!
+ * Register a block's constructor into the factory:
+ * The arguments to this macro must be the types of each constructor argument.
+ * Example: GRAS_REGISTER_FACTORY2("/proj/my_block", MyBlock, std::string, size_t)
+ * Declare this macro at the global scope in a cpp file.
+ * The block will register at static initialization time.
+ */
+#define GRAS_REGISTER_FACTORY10(name, type, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) \
+    static gras::Element *make_ ## type(const A0 &a0, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8, const A9 &a9) \
+    { return new type(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); } \
+    GRAS_REGISTER_FACTORY(name, make_##type)
+
 #include <gras/detail/factory.hpp>
 
 #endif /*INCLUDED_GRAS_FACTORY_HPP*/