WTF::HashTable: Implement move semantics for keys and values.

third_party/WebKit/Source/wtf/HashMap.h

 /*
  * Copyright (C) 2005, 2006, 2007, 2008, 2011 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 109 matching lines @@
     const HashMapValuesProxy& values() const { return static_cast<const HashMapValuesProxy&>(*this); }
 
     iterator find(KeyPeekInType);
     const_iterator find(KeyPeekInType) const;
     bool contains(KeyPeekInType) const;
     MappedPeekType get(KeyPeekInType) const;
 
     // replaces value but not key if key is already present return value is a
     // pair of the iterator to the key location, and a boolean that's true if a
     // new value was actually added
-    AddResult set(KeyPeekInType, MappedPassInType);
+    template <typename IncomingKeyType, typename IncomingMappedType>
+    AddResult set(IncomingKeyType&&, IncomingMappedType&&);
 
     // does nothing if key is already present return value is a pair of the
     // iterator to the key location, and a boolean that's true if a new value
     // was actually added
-    AddResult add(KeyPeekInType, MappedPassInType);
+    template <typename IncomingKeyType, typename IncomingMappedType>
+    AddResult add(IncomingKeyType&&, IncomingMappedType&&);
 
     void remove(KeyPeekInType);
     void remove(iterator);
     void clear();
     template <typename Collection>
     void removeAll(const Collection& toBeRemoved) { WTF::removeAll(*this, toBeRemoved); }
 
     MappedPassOutType take(KeyPeekInType); // efficient combination of get with remove
 
     // An alternate version of find() that finds the object by hashing and
@@ skipping 13 matching lines @@
     //   static bool equal(const ValueType&, const T&);
     //   static translate(ValueType&, const T&, unsigned hashCode);
     template <typename HashTranslator, typename T> AddResult add(const T&, MappedPassInType);
 
     static bool isValidKey(KeyPeekInType);
 
     template <typename VisitorDispatcher>
     void trace(VisitorDispatcher visitor) { m_impl.trace(visitor); }
 
 private:
-    AddResult inlineAdd(KeyPeekInType, MappedPassInReferenceType);
+    template <typename IncomingKeyType, typename IncomingMappedType>
+    AddResult inlineAdd(IncomingKeyType&&, IncomingMappedType&&);
 
     HashTableType m_impl;
 };
 
 template <typename KeyArg, typename MappedArg, typename HashArg, typename KeyTraitsArg, typename MappedTraitsArg, typename Allocator>
 class HashMap<KeyArg, MappedArg, HashArg, KeyTraitsArg, MappedTraitsArg, Allocator>::HashMapKeysProxy :
     private HashMap<KeyArg, MappedArg, HashArg, KeyTraitsArg, MappedTraitsArg, Allocator> {
     DISALLOW_NEW();
 public:
     typedef HashMap<KeyArg, MappedArg, HashArg, KeyTraitsArg, MappedTraitsArg, Allocator> HashMapType;
@@ skipping 77 matching lines @@
     {
         return isHashTraitsEmptyValue<KeyTraits>(value.key);
     }
 };
 
 template <typename ValueTraits, typename HashFunctions>
 struct HashMapTranslator {
     STATIC_ONLY(HashMapTranslator);
     template <typename T> static unsigned hash(const T& key) { return HashFunctions::hash(key); }
     template <typename T, typename U> static bool equal(const T& a, const U& b) { return HashFunctions::equal(a, b); }
-    template <typename T, typename U, typename V> static void translate(T& location, const U& key, const V& mapped)
+    template <typename T, typename U, typename V> static void translate(T& location, U&& key, V&& mapped)
     {
-        location.key = key;
-        ValueTraits::ValueTraits::store(mapped, location.value);
+        location.key = std::forward<U>(key);
+        ValueTraits::ValueTraits::store(std::forward<V>(mapped), location.value);
     }
 };
 
 template <typename ValueTraits, typename Translator>
 struct HashMapTranslatorAdapter {
     STATIC_ONLY(HashMapTranslatorAdapter);
     template <typename T> static unsigned hash(const T& key) { return Translator::hash(key); }
     template <typename T, typename U> static bool equal(const T& a, const U& b) { return Translator::equal(a, b); }
-    template <typename T, typename U, typename V> static void translate(T& location, const U& key, const V& mapped, unsigned hashCode)
+    template <typename T, typename U, typename V> static void translate(T& location, U&& key, V&& mapped, unsigned hashCode)
     {
-        Translator::translate(location.key, key, hashCode);
-        ValueTraits::ValueTraits::store(mapped, location.value);
+        Translator::translate(location.key, std::forward<U>(key), hashCode);
+        ValueTraits::ValueTraits::store(std::forward<V>(mapped), location.value);
     }
 };
 
 template <typename T, typename U, typename V, typename W, typename X, typename Y>
 inline unsigned HashMap<T, U, V, W, X, Y>::size() const
 {
     return m_impl.size();
 }
 
 template <typename T, typename U, typename V, typename W, typename X, typename Y>
@@ skipping 68 matching lines @@
 
 template <typename T, typename U, typename V, typename W, typename X, typename Y>
 template <typename HashTranslator, typename TYPE>
 inline bool
 HashMap<T, U, V, W, X, Y>::contains(const TYPE& value) const
 {
     return m_impl.template contains<HashMapTranslatorAdapter<ValueTraits, HashTranslator>>(value);
 }
 
 template <typename T, typename U, typename V, typename W, typename X, typename Y>
+template <typename IncomingKeyType, typename IncomingMappedType>
 typename HashMap<T, U, V, W, X, Y>::AddResult
-HashMap<T, U, V, W, X, Y>::inlineAdd(KeyPeekInType key, MappedPassInReferenceType mapped)
+HashMap<T, U, V, W, X, Y>::inlineAdd(IncomingKeyType&& key, IncomingMappedType&& mapped)

[Mikhail, 2016/03/04 12:58:02]

think it's worth switching to 'auto HashMap<T, U, V, W, X, Y>::inlineAdd() ->
AddResult' syntax

[Yuta Kitamura, 2016/03/04 13:55:37]

That syntax is "to be discussed" section in chromium-cpp.appspot.com,
so I think it's premature to use it now.

 {
-    return m_impl.template add<HashMapTranslator<ValueTraits, HashFunctions>>(key, mapped);
+    return m_impl.template add<HashMapTranslator<ValueTraits, HashFunctions>>(std::forward<IncomingKeyType>(key), std::forward<IncomingMappedType>(mapped));
 }
 
 template <typename T, typename U, typename V, typename W, typename X, typename Y>
+template <typename IncomingKeyType, typename IncomingMappedType>
 typename HashMap<T, U, V, W, X, Y>::AddResult
-HashMap<T, U, V, W, X, Y>::set(KeyPeekInType key, MappedPassInType mapped)
+HashMap<T, U, V, W, X, Y>::set(IncomingKeyType&& key, IncomingMappedType&& mapped)
 {
-    AddResult result = inlineAdd(key, mapped);
+    AddResult result = inlineAdd(std::forward<IncomingKeyType>(key), std::forward<IncomingMappedType>(mapped));
     if (!result.isNewEntry) {
         // The inlineAdd call above found an existing hash table entry; we need
         // to set the mapped value.
-        MappedTraits::store(mapped, result.storedValue->value);
+        //
+        // It's safe to call std::forward again, because |mapped| isn't moved if there's an existing entry.
+        MappedTraits::store(std::forward<IncomingMappedType>(mapped), result.storedValue->value);
     }
     return result;
 }
 
 template <typename T, typename U, typename V, typename W, typename X, typename Y>
 template <typename HashTranslator, typename TYPE>
 typename HashMap<T, U, V, W, X, Y>::AddResult
 HashMap<T, U, V, W, X, Y>::add(const TYPE& key, MappedPassInType value)
 {
     return m_impl.template addPassingHashCode<HashMapTranslatorAdapter<ValueTraits, HashTranslator>>(key, value);
 }
 
 template <typename T, typename U, typename V, typename W, typename X, typename Y>
+template <typename IncomingKeyType, typename IncomingMappedType>
 typename HashMap<T, U, V, W, X, Y>::AddResult
-HashMap<T, U, V, W, X, Y>::add(KeyPeekInType key, MappedPassInType mapped)
+HashMap<T, U, V, W, X, Y>::add(IncomingKeyType&& key, IncomingMappedType&& mapped)
 {
-    return inlineAdd(key, mapped);
+    return inlineAdd(std::forward<IncomingKeyType>(key), std::forward<IncomingMappedType>(mapped));
 }
 
 template <typename T, typename U, typename V, typename W, typename X, typename Y>
 typename HashMap<T, U, V, W, X, Y>::MappedPeekType
 HashMap<T, U, V, W, X, Y>::get(KeyPeekInType key) const
 {
     ValueType* entry = const_cast<HashTableType&>(m_impl).lookup(key);
     if (!entry)
         return MappedTraits::peek(MappedTraits::emptyValue());
     return MappedTraits::peek(entry->value);
@@ skipping 103 matching lines @@
     STATIC_ONLY(NeedsTracing);
     static const bool value = false;
 };
 #endif
 
 } // namespace WTF
 
 using WTF::HashMap;
 
 #endif // WTF_HashMap_h