Clarified addAttr behavior and added setAttr, changed any implementation

include/aidge/utils/DynamicAttributes.hpp

@@ -28,34 +28,6 @@ namespace Aidge {
 ///\todo store also a fix-sized code that indicates the type
 ///\todo managing complex types or excluding non-trivial, non-aggregate types
 class DynamicAttributes : public Attributes {
-private:
-    template<typename _ValueType>
-    inline _ValueType& any_cast_ref(const _any& __any)
-    {
-        using _Up =  std::remove_cv_t<std::remove_reference_t<_ValueType>>;
-        assert(((std::is_reference<_ValueType>::value || std::is_copy_constructible<_ValueType>::value) && "Template argument must be a reference or CopyConstructible type"));
-        assert((std::is_constructible<_ValueType, const _Up&>::value && "Template argument must be constructible from a const value."));
-        assert(std::is_object<_Up>::value);
-        assert(__any.type() == typeid(_Up));
-        if (_any::Manager<_Up>::access(&__any)) { // assess if _any object is empty
-            return *static_cast<_ValueType*>(_any::Manager<_Up>::access(&__any));
-        }
-        throw std::bad_cast();
-    }
-
-    template<typename _ValueType>
-    inline const _ValueType& any_cast_ref(const _any& __any) const
-    {
-        using _Up =  std::remove_cv_t<std::remove_reference_t<_ValueType>>;
-        assert(((std::is_reference<_ValueType>::value || std::is_copy_constructible<_ValueType>::value) && "Template argument must be a reference or CopyConstructible type"));
-        assert((std::is_constructible<_ValueType, const _Up&>::value && "Template argument must be constructible from a const value."));
-        assert(std::is_object<_Up>::value);
-        assert(__any.type() == typeid(_Up));
-        if (_any::Manager<_Up>::access(&__any)) { // assess if _any object is empty
-            return *static_cast<const _ValueType*>(_any::Manager<_Up>::access(&__any));
-        }
-        throw std::bad_cast();
-    }
 public:
     /**
      * \brief Returning an Attribute identified by its name
@@ -67,23 +39,33 @@ public:
      */
     template<class T> T& getAttr(const std::string& name)
     {
-        return any_cast_ref<T>(mAttrs.at(name));
+        return libany::any_cast<T&>(mAttrs.at(name));
     }
 
     template<class T> const T& getAttr(const std::string& name) const
     {
-        return any_cast_ref<T>(mAttrs.at(name));
+        return libany::any_cast<const T&>(mAttrs.at(name));
     }
 
-    ///\brief Add a Attribute value, identified by its name
+    ///\brief Add a new Attribute, identified by its name. If it already exists, asserts.
     ///\tparam T expected Attribute type
     ///\param name Attribute name
     ///\param value Attribute value
-    ///\todo Pass value by ref if large or not trivial
-    ///\bug If Attribute already exists, its value is changed
     template<class T> void addAttr(const std::string& name, T&& value)
     {
-        mAttrs.emplace(std::make_pair(name, _any(std::forward<T>(value))));
+        const auto& res = mAttrs.emplace(std::make_pair(name, libany::any(std::forward<T>(value))));
+        assert(res.second && "attribute already exists");
+    }
+
+    ///\brief Set an Attribute value, identified by its name. If it already exists, its value (and type, if different) is changed.
+    ///\tparam T expected Attribute type
+    ///\param name Attribute name
+    ///\param value Attribute value
+    template<class T> void setAttr(const std::string& name, T&& value)
+    {
+        auto res = mAttrs.emplace(std::make_pair(name, libany::any(std::forward<T>(value))));
+        if (!res.second)
+            res.first->second = std::move(libany::any(std::forward<T>(value)));
     }
 
     //////////////////////////////////////
@@ -136,7 +118,7 @@ public:
     #endif
 
 private:
-    std::map<std::string, _any> mAttrs;
+    std::map<std::string, libany::any> mAttrs;
 };
 
 }

python_binding/utils/pybind_Parameter.cpp

@@ -12,6 +12,7 @@ void init_Attributes(py::module& m){
     .def("get_attr", &Attributes::getAttrPy, py::arg("name"));
 
     py::class_<DynamicAttributes, std::shared_ptr<DynamicAttributes>, Attributes>(m, "DynamicAttributes")
+    // add
     .def("add_attr", &DynamicAttributes::addAttr<bool>)
     .def("add_attr", &DynamicAttributes::addAttr<int>)
     .def("add_attr", &DynamicAttributes::addAttr<float>)
@@ -19,7 +20,16 @@ void init_Attributes(py::module& m){
     .def("add_attr", &DynamicAttributes::addAttr<std::vector<bool>>)
     .def("add_attr", &DynamicAttributes::addAttr<std::vector<int>>)
     .def("add_attr", &DynamicAttributes::addAttr<std::vector<float>>)
-    .def("add_attr", &DynamicAttributes::addAttr<std::vector<std::string>>);
+    .def("add_attr", &DynamicAttributes::addAttr<std::vector<std::string>>)
+    // set
+    .def("set_attr", &DynamicAttributes::setAttr<bool>)
+    .def("set_attr", &DynamicAttributes::setAttr<int>)
+    .def("set_attr", &DynamicAttributes::setAttr<float>)
+    .def("set_attr", &DynamicAttributes::setAttr<std::string>)
+    .def("set_attr", &DynamicAttributes::setAttr<std::vector<bool>>)
+    .def("set_attr", &DynamicAttributes::setAttr<std::vector<int>>)
+    .def("set_attr", &DynamicAttributes::setAttr<std::vector<float>>)
+    .def("set_attr", &DynamicAttributes::setAttr<std::vector<std::string>>);
 }
 }