added bool return value for all registration/unregistration methods

The reason for that is, we don't want to store registerared methods,
which we cannot store anyway (property name already exist, function name+signature already exist, etc...)

Therefore added bool return value for method erase() in flat_map and flat_multimap

Added unit test for type::is_base_of

src/rttr/detail/misc/flat_map.h

@@ -171,7 +171,7 @@ class flat_map
 
 // older versions of gcc stl, have no support for const_iterator in std::vector<T>::erase(const_iterator)
 #if RTTR_NO_CXX11_CONST_EREASE_SUPPORT_IN_STL
-        void erase(const Key& key)
+        bool erase(const Key& key)
         {
             iterator_key itr = find_key(key);
             if (itr != m_key_list.end())
@@ -181,12 +181,14 @@ class flat_map
                 {
                     m_key_list.erase(itr);
                     m_value_list.erase(value_itr);
+                    return true;
                 }
             }
 
+            return false;
         }
 #else
-        void erase(const Key& key)
+        bool erase(const Key& key)
         {
             const_iterator_key itr = find_key_const(key);
             if (itr != m_key_list.end())
@@ -196,9 +198,11 @@ class flat_map
                 {
                     m_key_list.erase(itr);
                     m_value_list.erase(value_itr);
+                    return true;
                 }
             }
 
+            return false;
         }
 #endif
 

src/rttr/detail/misc/flat_multimap.h

@@ -149,7 +149,7 @@ class flat_multimap
         }
 // older versions of gcc stl, have no support for const_iterator in std::vector<T>::erase(const_iterator)
 #if RTTR_COMPILER == RTTR_COMPILER_GNUC && RTTR_COMP_VER < 490
-        void erase(const Key& key)
+        bool erase(const Key& key)
         {
             iterator_key itr = find_key(key);
             if (itr != m_key_list.end())
@@ -159,12 +159,14 @@ class flat_multimap
                 {
                     m_key_list.erase(itr);
                     m_value_list.erase(value_itr);
+                     return true;
                 }
             }
 
+            return false;
         }
 #else
-        void erase(const Key& key)
+        bool erase(const Key& key)
         {
             const_iterator_key itr = find_key_const(key);
             if (itr != m_key_list.end())
@@ -174,9 +176,11 @@ class flat_multimap
                 {
                     m_key_list.erase(itr);
                     m_value_list.erase(value_itr);
+                    return true;
                 }
             }
 
+            return false;
         }
 #endif
 

src/rttr/detail/registration/registration_manager.h

@@ -73,68 +73,68 @@ class RTTR_LOCAL registration_manager
 
         void add_item(std::unique_ptr<constructor_wrapper_base> ctor)
         {
-            type_register::register_constructor(ctor.get());
-            m_constructors.push_back(std::move(ctor));
+            if (type_register::register_constructor(ctor.get()))
+                m_constructors.push_back(std::move(ctor));
         }
 
         void add_item(std::unique_ptr<destructor_wrapper_base> dtor)
         {
-            type_register::register_destructor(dtor.get());
-            m_destructors.push_back(std::move(dtor));
+            if (type_register::register_destructor(dtor.get()))
+                m_destructors.push_back(std::move(dtor));
         }
 
         void add_item(std::unique_ptr<property_wrapper_base> prop)
         {
-            type_register::register_property(prop.get());
-            m_properties.push_back(std::move(prop));
+            if (type_register::register_property(prop.get()))
+                m_properties.push_back(std::move(prop));
         }
 
         void add_item(std::unique_ptr<method_wrapper_base> meth)
         {
-            type_register::register_method(meth.get());
-            m_methods.push_back(std::move(meth));
+            if (type_register::register_method(meth.get()))
+                m_methods.push_back(std::move(meth));
         }
 
         void add_item(std::unique_ptr<enumeration_wrapper_base> enum_)
         {
-            type_register::register_enumeration(enum_.get());
-            m_enumerations.push_back(std::move(enum_));
+            if (type_register::register_enumeration(enum_.get()))
+                m_enumerations.push_back(std::move(enum_));
         }
 
         void add_global_item(std::unique_ptr<property_wrapper_base> prop)
         {
-            type_register::register_global_property(prop.get());
-            m_global_properties.push_back(std::move(prop));
+            if (type_register::register_global_property(prop.get()))
+                m_global_properties.push_back(std::move(prop));
         }
 
         void add_global_item(std::unique_ptr<method_wrapper_base> meth)
         {
-            type_register::register_global_method(meth.get());
-            m_global_methods.push_back(std::move(meth));
+            if (type_register::register_global_method(meth.get()))
+                m_global_methods.push_back(std::move(meth));
         }
 
         void add_global_item(std::unique_ptr<enumeration_wrapper_base> enum_)
         {
-            type_register::register_enumeration(enum_.get());
-            m_enumerations.push_back(std::move(enum_));
+            if (type_register::register_enumeration(enum_.get()))
+                m_enumerations.push_back(std::move(enum_));
         }
 
         void add_item(std::unique_ptr<type_converter_base> conv)
         {
-            type_register::register_converter(conv.get());
-            m_type_converters.push_back(std::move(conv));
+            if (type_register::register_converter(conv.get()))
+                m_type_converters.push_back(std::move(conv));
         }
 
         void add_equal_cmp(std::unique_ptr<type_comparator_base> cmp)
         {
-            type_register::register_equal_comparator(cmp.get());
-            m_type_equal_cmps.push_back(std::move(cmp));
+            if (type_register::register_equal_comparator(cmp.get()))
+                m_type_equal_cmps.push_back(std::move(cmp));
         }
 
         void add_less_than_cmp(std::unique_ptr<type_comparator_base> cmp)
         {
-            type_register::register_less_than_comparator(cmp.get());
-            m_type_less_than_cmps.push_back(std::move(cmp));
+            if (type_register::register_less_than_comparator(cmp.get()))
+                m_type_less_than_cmps.push_back(std::move(cmp));
         }
 
         void set_disable_unregister()