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;
typedef typename maker::cxx_data_allocator cxx_data_allocator;
template <typename Less>
- using less_wrapper = typename maker::less_wrapper< Less >;
+ using less_wrapper = typename maker::template less_wrapper< Less >;
template <bool IsConst>
using iterator_type = typename base_class::template iterator_type<IsConst>;
@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());
}
@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
@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( key, f, bAllowInsert );
+ return base_class::update( value_type( key_type( key ), mapped_type()), f, bAllowInsert );
}
/// Insert or update
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
If \p key is not found the function returns \p end().
*/
template <typename Q, typename Less>
- iterator find_with( Q& key, Less pred ) const
+ iterator find_with( Q const& key, Less pred ) const
{
CDS_UNUSED( pred );
return base_class::find_with( key, less_wrapper<Less>());
// 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>
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>