Migrate WTF::HashMap::add() to ::insert()

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 131 matching lines @@
   // pair of the iterator to the key location, and a boolean that's true if a
   // new value was actually added
   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
   template <typename IncomingKeyType, typename IncomingMappedType>
   AddResult add(IncomingKeyType&&, IncomingMappedType&&);
+  template <typename IncomingKeyType, typename IncomingMappedType>
+  AddResult insert(IncomingKeyType&&, IncomingMappedType&&);
 
   void remove(KeyPeekInType);
   void remove(iterator);
   void clear();
   template <typename Collection>
   void removeAll(const Collection& toBeRemoved) {
     WTF::removeAll(*this, toBeRemoved);
   }
 
   MappedType take(KeyPeekInType);  // efficient combination of get with remove
@@ skipping 13 matching lines @@
   // An alternate version of add() that finds the object by hashing and
   // comparing with some other type, to avoid the cost of type conversion if
   // the object is already in the table. HashTranslator must have the
   // following function members:
   //   static unsigned hash(const T&);
   //   static bool equal(const ValueType&, const T&);
   //   static translate(ValueType&, const T&, unsigned hashCode);
   template <typename HashTranslator,
             typename IncomingKeyType,
             typename IncomingMappedType>
   AddResult add(IncomingKeyType&&, IncomingMappedType&&);

[haraken, 2017/02/03 03:47:13]

Shall we add a TODO that add() is deprecated?

+  template <typename HashTranslator,
+            typename IncomingKeyType,
+            typename IncomingMappedType>
+  AddResult insert(IncomingKeyType&&, IncomingMappedType&&);
 
   static bool isValidKey(KeyPeekInType);
 
   template <typename VisitorDispatcher>
   void trace(VisitorDispatcher visitor) {
     m_impl.trace(visitor);
   }
 
  private:
   template <typename IncomingKeyType, typename IncomingMappedType>
@@ skipping 148 matching lines @@
 template <typename T,
           typename U,
           typename V,
           typename W,
           typename X,
           typename Y>
 HashMap<T, U, V, W, X, Y>::HashMap(std::initializer_list<ValueType> elements) {
   if (elements.size())
     m_impl.reserveCapacityForSize(elements.size());
   for (const ValueType& element : elements)
-    add(element.key, element.value);
+    insert(element.key, element.value);
 }
 
 template <typename T,
           typename U,
           typename V,
           typename W,
           typename X,
           typename Y>
 auto HashMap<T, U, V, W, X, Y>::operator=(
     std::initializer_list<ValueType> elements) -> HashMap& {
@@ skipping 203 matching lines @@
       std::forward<IncomingKeyType>(key),
       std::forward<IncomingMappedType>(mapped));
 }
 
 template <typename T,
           typename U,
           typename V,
           typename W,
           typename X,
           typename Y>
+template <typename HashTranslator,
+          typename IncomingKeyType,
+          typename IncomingMappedType>
+auto HashMap<T, U, V, W, X, Y>::insert(IncomingKeyType&& key,
+                                       IncomingMappedType&& mapped)
+    -> AddResult {
+  return m_impl.template addPassingHashCode<
+      HashMapTranslatorAdapter<ValueTraits, HashTranslator>>(
+      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>::add(
     IncomingKeyType&& key,
     IncomingMappedType&& mapped) {
   return inlineAdd(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>::insert(
+    IncomingKeyType&& key,
+    IncomingMappedType&& 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);
 }
 
 template <typename T,
           typename U,
@@ skipping 134 matching lines @@
   iterator end = collection.end().values();
   for (unsigned i = 0; it != end; ++it, ++i)
     vector[i] = *it;
 }
 
 }  // namespace WTF
 
 using WTF::HashMap;
 
 #endif  // WTF_HashMap_h