WTF: Implement move semantics for values of {List,Linked}HashSet.

third_party/WebKit/Source/wtf/LinkedHashSet.h

 /*
  * Copyright (C) 2005, 2006, 2007, 2008, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2011, Benjamin Poulain <ikipou@gmail.com>
  *
  * 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,
@@ skipping 227 matching lines @@
 
     // An alternate version of find() that finds the object by hashing and comparing
     // with some other type, to avoid the cost of type conversion.
     // The HashTranslator interface is defined in HashSet.
     template<typename HashTranslator, typename T> iterator find(const T&);
     template<typename HashTranslator, typename T> const_iterator find(const T&) const;
     template<typename HashTranslator, typename T> bool contains(const T&) const;
 
     // The return value of add is a pair of a pointer to the stored value,
     // and a bool that is true if an new entry was added.
-    AddResult add(ValuePeekInType);
+    template <typename IncomingValueType>
+    AddResult add(IncomingValueType&&);
 
     // Same as add() except that the return value is an
     // iterator. Useful in cases where it's needed to have the
     // same return value as find() and where it's not possible to
     // use a pointer to the storedValue.
-    iterator addReturnIterator(ValuePeekInType);
+    template <typename IncomingValueType>
+    iterator addReturnIterator(IncomingValueType&&);
 
     // Add the value to the end of the collection. If the value was already in
     // the list, it is moved to the end.
-    AddResult appendOrMoveToLast(ValuePeekInType);
+    template <typename IncomingValueType>
+    AddResult appendOrMoveToLast(IncomingValueType&&);
 
     // Add the value to the beginning of the collection. If the value was already in
     // the list, it is moved to the beginning.
-    AddResult prependOrMoveToFirst(ValuePeekInType);
+    template <typename IncomingValueType>
+    AddResult prependOrMoveToFirst(IncomingValueType&&);
 
-    AddResult insertBefore(ValuePeekInType beforeValue, ValuePeekInType newValue);
-    AddResult insertBefore(iterator it, ValuePeekInType newValue) { return m_impl.template add<NodeHashFunctions>(newValue, it.node()); }
+    template <typename IncomingValueType>
+    AddResult insertBefore(ValuePeekInType beforeValue, IncomingValueType&& newValue);
+    template <typename IncomingValueType>
+    AddResult insertBefore(iterator it, IncomingValueType&& newValue) { return m_impl.template add<NodeHashFunctions>(std::forward<IncomingValueType>(newValue), it.node()); }
 
     void remove(ValuePeekInType);
     void remove(iterator);
     void clear() { m_impl.clear(); }
     template<typename Collection>
     void removeAll(const Collection& other) { WTF::removeAll(*this, other); }
 
     template<typename VisitorDispatcher>
     void trace(VisitorDispatcher visitor) { m_impl.trace(visitor); }
 
@@ skipping 20 matching lines @@
 template<typename Value, typename HashFunctions, typename Allocator>
 struct LinkedHashSetTranslator {
     STATIC_ONLY(LinkedHashSetTranslator);
     typedef LinkedHashSetNode<Value, Allocator> Node;
     typedef LinkedHashSetNodeBase NodeBase;
     typedef typename HashTraits<Value>::PeekInType ValuePeekInType;
     static unsigned hash(const Node& node) { return HashFunctions::hash(node.m_value); }
     static unsigned hash(const ValuePeekInType& key) { return HashFunctions::hash(key); }
     static bool equal(const Node& a, const ValuePeekInType& b) { return HashFunctions::equal(a.m_value, b); }
     static bool equal(const Node& a, const Node& b) { return HashFunctions::equal(a.m_value, b.m_value); }
-    static void translate(Node& location, ValuePeekInType key, NodeBase* anchor)
+    template <typename IncomingValueType>
+    static void translate(Node& location, IncomingValueType&& key, NodeBase* anchor)
     {
         anchor->insertBefore(location);
-        location.m_value = key;
+        location.m_value = std::forward<IncomingValueType>(key);
     }
 
     // Empty (or deleted) slots have the m_next pointer set to null, but we
     // don't do anything to the other fields, which may contain junk.
     // Therefore you can't compare a newly constructed empty value with a
     // slot and get the right answer.
     static const bool safeToCompareToEmptyOrDeleted = false;
 };
 
 template<typename Value, typename Allocator>
@@ skipping 327 matching lines @@
     return m_impl.template contains<LinkedHashSetTranslatorAdapter<HashTranslator>>(value);
 }
 
 template<typename T, typename U, typename V, typename W>
 inline bool LinkedHashSet<T, U, V, W>::contains(ValuePeekInType value) const
 {
     return m_impl.template contains<NodeHashFunctions>(value);
 }
 
 template<typename Value, typename HashFunctions, typename Traits, typename Allocator>
-typename LinkedHashSet<Value, HashFunctions, Traits, Allocator>::AddResult LinkedHashSet<Value, HashFunctions, Traits, Allocator>::add(ValuePeekInType value)
+template<typename IncomingValueType>
+typename LinkedHashSet<Value, HashFunctions, Traits, Allocator>::AddResult LinkedHashSet<Value, HashFunctions, Traits, Allocator>::add(IncomingValueType&& value)
 {
-    return m_impl.template add<NodeHashFunctions>(value, &m_anchor);
+    return m_impl.template add<NodeHashFunctions>(std::forward<IncomingValueType>(value), &m_anchor);
 }
 
 template<typename T, typename U, typename V, typename W>
-typename LinkedHashSet<T, U, V, W>::iterator LinkedHashSet<T, U, V, W>::addReturnIterator(ValuePeekInType value)
+template<typename IncomingValueType>
+typename LinkedHashSet<T, U, V, W>::iterator LinkedHashSet<T, U, V, W>::addReturnIterator(IncomingValueType&& value)
 {
-    typename ImplType::AddResult result = m_impl.template add<NodeHashFunctions>(value, &m_anchor);
+    typename ImplType::AddResult result = m_impl.template add<NodeHashFunctions>(std::forward<IncomingValueType>(value), &m_anchor);
     return makeIterator(result.storedValue);
 }
 
 template<typename T, typename U, typename V, typename W>
-typename LinkedHashSet<T, U, V, W>::AddResult LinkedHashSet<T, U, V, W>::appendOrMoveToLast(ValuePeekInType value)
+template<typename IncomingValueType>
+typename LinkedHashSet<T, U, V, W>::AddResult LinkedHashSet<T, U, V, W>::appendOrMoveToLast(IncomingValueType&& value)
 {
-    typename ImplType::AddResult result = m_impl.template add<NodeHashFunctions>(value, &m_anchor);
+    typename ImplType::AddResult result = m_impl.template add<NodeHashFunctions>(std::forward<IncomingValueType>(value), &m_anchor);
     Node* node = result.storedValue;
     if (!result.isNewEntry) {
         node->unlink();
         m_anchor.insertBefore(*node);
     }
     return result;
 }
 
 template<typename T, typename U, typename V, typename W>
-typename LinkedHashSet<T, U, V, W>::AddResult LinkedHashSet<T, U, V, W>::prependOrMoveToFirst(ValuePeekInType value)
+template<typename IncomingValueType>
+typename LinkedHashSet<T, U, V, W>::AddResult LinkedHashSet<T, U, V, W>::prependOrMoveToFirst(IncomingValueType&& value)
 {
-    typename ImplType::AddResult result = m_impl.template add<NodeHashFunctions>(value, m_anchor.m_next);
+    typename ImplType::AddResult result = m_impl.template add<NodeHashFunctions>(std::forward<IncomingValueType>(value), m_anchor.m_next);
     Node* node = result.storedValue;
     if (!result.isNewEntry) {
         node->unlink();
         m_anchor.insertAfter(*node);
     }
     return result;
 }
 
 template<typename T, typename U, typename V, typename W>
-typename LinkedHashSet<T, U, V, W>::AddResult LinkedHashSet<T, U, V, W>::insertBefore(ValuePeekInType beforeValue, ValuePeekInType newValue)
+template<typename IncomingValueType>
+typename LinkedHashSet<T, U, V, W>::AddResult LinkedHashSet<T, U, V, W>::insertBefore(ValuePeekInType beforeValue, IncomingValueType&& newValue)
 {
-    return insertBefore(find(beforeValue), newValue);
+    return insertBefore(find(beforeValue), std::forward<IncomingValueType>(newValue));
 }
 
 template<typename T, typename U, typename V, typename W>
 inline void LinkedHashSet<T, U, V, W>::remove(iterator it)
 {
     if (it == end())
         return;
     m_impl.remove(it.node());
 }
 
@@ skipping 62 matching lines @@
     STATIC_ONLY(NeedsTracing);
     static const bool value = false;
 };
 #endif
 
 } // namespace WTF
 
 using WTF::LinkedHashSet;
 
 #endif /* WTF_LinkedHashSet_h */