WTF: Support std::initializer_list in HashMap.

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
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  *
  */
 
 #ifndef WTF_HashMap_h
 #define WTF_HashMap_h
 
 #include "wtf/HashTable.h"
 #include "wtf/allocator/PartitionAllocator.h"
+#include <initializer_list>
 
 namespace WTF {
 
 template <typename KeyTraits, typename MappedTraits>
 struct HashMapValueTraits;
 
 struct KeyValuePairKeyExtractor {
   STATIC_ONLY(KeyValuePairKeyExtractor);
   template <typename T>
   static const typename T::KeyType& extract(const T& p) {
@@ skipping 45 matching lines @@
   HashMap() {
     static_assert(Allocator::isGarbageCollected ||
                       !IsPointerToGarbageCollectedType<KeyArg>::value,
                   "Cannot put raw pointers to garbage-collected classes into "
                   "an off-heap HashMap.  Use HeapHashMap<> instead.");
     static_assert(Allocator::isGarbageCollected ||
                       !IsPointerToGarbageCollectedType<MappedArg>::value,
                   "Cannot put raw pointers to garbage-collected classes into "
                   "an off-heap HashMap.  Use HeapHashMap<> instead.");
   }
+  HashMap(const HashMap&) = default;
+  HashMap& operator=(const HashMap&) = default;
+  HashMap(HashMap&&) = default;
+  HashMap& operator=(HashMap&&) = default;
+
+  // For example, HashMap<int, int>({{1, 11}, {2, 22}, {3, 33}}) will give you
+  // a HashMap containing a mapping {1 -> 11, 2 -> 22, 3 -> 33}.
+  HashMap(std::initializer_list<ValueType> elements);
+  HashMap& operator=(std::initializer_list<ValueType> elements);
 
   typedef HashTableIteratorAdapter<HashTableType, ValueType> iterator;
   typedef HashTableConstIteratorAdapter<HashTableType, ValueType>
       const_iterator;
   typedef typename HashTableType::AddResult AddResult;
 
   void swap(HashMap& ref) { m_impl.swap(ref.m_impl); }
 
   unsigned size() const;
   unsigned capacity() const;
@@ skipping 228 matching lines @@
     ValueTraits::ValueTraits::store(std::forward<V>(mapped), location.value);
   }
 };
 
 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);

[tzik, 2017/01/18 13:36:40]

Can we std::move() them?

[Yuta Kitamura, 2017/01/19 06:07:04]

No, because std::initializer_list<T>::reference is const T&;
the type of |element| can't be ValueType&&.

[Yuta Kitamura, 2017/01/19 06:08:08]

typo: ValueType&& -> ValueType&.

+}
+
+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& {
+  *this = HashMap(std::move(elements));
+  return *this;
+}
+
+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 351 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