Fixed explicit ctor stuff

[libcds.git] / cds / container / impl / iterable_kvlist.h

diff --git a/cds/container/impl/iterable_kvlist.h b/cds/container/impl/iterable_kvlist.h
index 2826d2e1996507ceaff826dad3273d027b9be249..aaad301e17d8d31f4452f6e109f05252b5878d10 100644 (file)
--- a/cds/container/impl/iterable_kvlist.h
+++ b/cds/container/impl/iterable_kvlist.h
@@ -123,9 +123,9 @@ namespace cds { namespace container {
 
     public:
 #ifdef CDS_DOXYGEN_INVOKED
-        typedef Key                                 key_type        ;   ///< Key type
-        typedef Value                               mapped_type     ;   ///< Type of value stored in the list
-        typedef std::pair<key_type const, mapped_type> value_type   ;   ///< key/value pair stored in the list
+        typedef Key                                 key_type;      ///< Key type
+        typedef Value                               mapped_type;   ///< Type of value stored in the list
+        typedef std::pair<key_type const, mapped_type> value_type; ///< key/value pair stored in the list
 #else
         typedef typename maker::key_type    key_type;
         typedef typename maker::mapped_type mapped_type;
@@ -249,15 +249,7 @@ namespace cds { namespace container {
             @note The function is supported only if \ref mapped_type is default constructible
         */
         template <typename K>
-#ifdef CDS_DOXYGEN_INVOKED
-        bool
-#else
-        typename std::enable_if<
-            std::is_same<K, K>::value && std::is_default_constructible< mapped_type >::value,
-            bool
-        >::type
-#endif
-        insert( K const& key )
+        bool insert( K const& key )
         {
             return base_class::emplace( key, mapped_type());
         }
@@ -309,17 +301,9 @@ namespace cds { namespace container {
             @note The function is supported only if \ref mapped_type is default constructible
         */
         template <typename K, typename Func>
-#ifdef CDS_DOXYGEN_INVOKED
-        bool
-#else
-        typename std::enable_if<
-            std::is_same<K, K>::value && std::is_default_constructible< mapped_type >::value,
-            bool
-        >::type
-#endif
-        insert_with( K const& key, Func func )
+        bool insert_with( K const& key, Func func )
         {
-            return base_class::insert( value_type( key, mapped_type()), func );
+            return base_class::insert( value_type( key_type( key ), mapped_type()), func );
         }
 
         /// Updates data by \p key
@@ -351,17 +335,9 @@ namespace cds { namespace container {
             @note The function is supported only if \ref mapped_type is default constructible
         */
         template <typename K, typename Func>
-#ifdef CDS_DOXYGEN_INVOKED
-        std::pair<bool, bool>
-#else
-        typename std::enable_if<
-            std::is_same<K, K>::value && std::is_default_constructible< mapped_type >::value,
-            std::pair<bool, bool>
-        >::type
-#endif
-        update( K const& key, Func f, bool bAllowInsert = true )
+        std::pair<bool, bool> update( K const& key, Func f, bool bAllowInsert = true )
         {
-            return base_class::update( value_type( key, mapped_type()), f, bAllowInsert );
+            return base_class::update( value_type( key_type( key ), mapped_type()), f, bAllowInsert );
         }
 
         /// Insert or update
@@ -380,7 +356,7 @@ namespace cds { namespace container {
         template <typename Q, typename V >
         std::pair<bool, bool> upsert( Q&& key, V&& val, bool bInsert = true )
         {
-            return base_class::upsert( value_type( std::forward<Q>( key ), std::forward<V>( val )), bInsert );
+            return base_class::upsert( value_type( key_type( std::forward<Q>( key )), mapped_type( std::forward<V>( val ))), bInsert );
         }
 
         /// Inserts a new node using move semantics
@@ -674,21 +650,21 @@ namespace cds { namespace container {
         // Split-list support
 
         template <typename K>
-        bool insert_at( head_type& refHead, const K& key )
+        bool insert_at( head_type& refHead, K const& key )
         {
-            return base_class::insert_at( refHead, value_type( key, mapped_type() ));
+            return base_class::insert_at( refHead, value_type( key_type( key ), mapped_type() ));
         }
 
         template <typename K, typename V>
-        bool insert_at( head_type& refHead, const K& key, const V& val )
+        bool insert_at( head_type& refHead, const K& key, V const& val )
         {
-            return base_class::insert_at( refHead, value_type( key, val ));
+            return base_class::insert_at( refHead, value_type( key_type( key ), val ));
         }
 
         template <typename K, typename Func>
-        bool insert_with_at( head_type& refHead, const K& key, Func f )
+        bool insert_with_at( head_type& refHead, K const& key, Func f )
         {
-            return base_class::insert_at( refHead, value_type( key, mapped_type()), f );
+            return base_class::insert_at( refHead, value_type( key_type( key ), mapped_type()), f );
         }
 
         template <typename K, typename... Args>
@@ -700,7 +676,7 @@ namespace cds { namespace container {
         template <typename K, typename Func>
         std::pair<bool, bool> update_at( head_type& refHead, const K& key, Func f, bool bAllowInsert )
         {
-            return base_class::update_at( refHead, value_type( key, mapped_type()), f, bAllowInsert );
+            return base_class::update_at( refHead, value_type( key_type( key ), mapped_type()), f, bAllowInsert );
         }
 
         template <typename K, typename Compare>