Unified interface for attributes

In this MR, I propose a more unified attributes handling.

This MR, once merged, will break every other MR!

Refactor

• Use the term "attribute" instead of "parameter"
• Uniformized function naming ("hasAttr" and "getAttr" + "addAttr"/"setAttr"/"delAttr" for DynamicAttributes)
• Parametrizable -> StaticAttributes
• CParameter -> DynamicAttributes
• Adding abstract class Attributes to uniformize Dynamic & StaticAttributes

Also

• Includes fix for bug #8 (closed) (as it may get lost in MR !9 (merged))
• Distinguish between "addAttr" (asserts if already exists) and "setAttr" (do not care if already exists)
• "Universal" Python binding for DynamicAttributes
• Added AIDGE_THROW_OR_ABORT macro

include/aidge/utils/StaticAttributes.hpp

@@ -95,11 +95,11 @@ public:
         assert(false && "attribute not found");
     }
 
-    template <typename R, std::size_t SIZE = std::tuple_size<std::tuple<T...>>::value-1>
+    template <typename R, std::size_t SIZE = std::tuple_size<std::tuple<T...>>::value>
     constexpr typename std::enable_if<(SIZE > 0), R&>::type getAttr(std::size_t i) {
-        if (i == SIZE) {
-            if (std::is_same<R, typename std::tuple_element<SIZE,std::tuple<T...>>::type>::value) {
-                return reinterpret_cast<R&>(std::get<SIZE>(mAttrs));
+        if (i == SIZE-1) {
+            if (std::is_same<R, typename std::tuple_element<SIZE-1,std::tuple<T...>>::type>::value) {
+                return reinterpret_cast<R&>(std::get<SIZE-1>(mAttrs));
             }
             else {
                 assert(false && "wrong attribute type");
@@ -110,25 +110,24 @@ public:
         }
     }
 
-    template <typename R, std::size_t SIZE = std::tuple_size<std::tuple<T...>>::value-1>
-    [[noreturn]] constexpr typename std::enable_if<(SIZE <= 0), R&>::type getAttr(std::size_t /*i*/) {
+    template <typename R, std::size_t SIZE = std::tuple_size<std::tuple<T...>>::value>
+    [[noreturn]] constexpr typename std::enable_if<(SIZE == 0), R&>::type getAttr(std::size_t /*i*/) {
         assert(false && "attribute not found");
     }
 
-    template <std::size_t SIZE = std::tuple_size<std::tuple<T...>>::value-1>
-    constexpr typename std::enable_if<(SIZE > 0), std::string>::type getAttrType(std::size_t i) const {
-        if (i == SIZE) {
-            return typeid(typename std::tuple_element<SIZE,std::tuple<T...>>::type).name();
+    template <std::size_t SIZE = std::tuple_size<std::tuple<T...>>::value>
+    constexpr typename std::enable_if<(SIZE > 0), const std::type_info&>::type getAttrType(std::size_t i) const {
+        if (i == SIZE-1) {
+            return typeid(typename std::tuple_element<SIZE-1,std::tuple<T...>>::type);
         }
         else {
             return getAttrType<SIZE-1>(i);
         }
     }
 
-    template <std::size_t SIZE = std::tuple_size<std::tuple<T...>>::value-1>
-    constexpr typename std::enable_if<(SIZE <= 0), std::string>::type getAttrType(std::size_t /*i*/) const {
+    template <std::size_t SIZE = std::tuple_size<std::tuple<T...>>::value>
+    [[noreturn]] constexpr typename std::enable_if<(SIZE == 0), const std::type_info&>::type getAttrType(std::size_t /*i*/) const {
         assert(false && "attribute not found");
-        return std::string();  // useless, but makes MSVC happy
     }
 
     constexpr const std::tuple<T...>& getStaticAttributes() const {
@@ -153,7 +152,7 @@ public:
     constexpr std::string getAttrType(const std::string& name) const override final {
         for (std::size_t i = 0; i < size(EnumStrings<ATTRS_ENUM>::data); ++i) {
             if (name == EnumStrings<ATTRS_ENUM>::data[i]) {
-                return getAttrType(i);
+                return getAttrType(i).name();
             }
         }