Save 100-300 KB footprint by not force inlining HashTable functions

Source/wtf/ListHashSet.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 641 matching lines @@
     struct ListHashSetTranslator {
         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->m_value, b); }
         template<typename T, typename U, typename V> static void translate(T*& location, const U& key, const V& allocator)
         {
             location = new (const_cast<V*>(&allocator)) T(key);
         }
     };
 
     template<typename T, size_t inlineCapacity, typename U, typename V>
-    inline ListHashSet<T, inlineCapacity, U, V>::ListHashSet()
+    ListHashSet<T, inlineCapacity, U, V>::ListHashSet()
         : m_head(0)
         , m_tail(0)
     {
     }
 
     template<typename T, size_t inlineCapacity, typename U, typename V>
-    inline ListHashSet<T, inlineCapacity, U, V>::ListHashSet(const ListHashSet& other)
+    ListHashSet<T, inlineCapacity, U, V>::ListHashSet(const ListHashSet& other)
         : m_head(0)
         , m_tail(0)
     {
         const_iterator end = other.end();
         for (const_iterator it = other.begin(); it != end; ++it)
             add(*it);
     }
 
     template<typename T, size_t inlineCapacity, typename U, typename V>
-    inline ListHashSet<T, inlineCapacity, U, V>& ListHashSet<T, inlineCapacity, U, V>::operator=(const ListHashSet& other)
+    ListHashSet<T, inlineCapacity, U, V>& ListHashSet<T, inlineCapacity, U, V>::operator=(const ListHashSet& other)
     {
         ListHashSet tmp(other);
         swap(tmp);
         return *this;
     }
 
     template<typename T, size_t inlineCapacity, typename U, typename V>
-    inline void ListHashSet<T, inlineCapacity, U, V>::swap(ListHashSet& other)
+    void ListHashSet<T, inlineCapacity, U, V>::swap(ListHashSet& other)
     {
         m_impl.swap(other.m_impl);
         std::swap(m_head, other.m_head);
         std::swap(m_tail, other.m_tail);
         this->m_allocatorProvider.swap(other.m_allocatorProvider);
     }
 
     template<typename T, size_t inlineCapacity, typename U, typename V>
-    inline void ListHashSet<T, inlineCapacity, U, V>::finalize()
+    void ListHashSet<T, inlineCapacity, U, V>::finalize()
     {
         COMPILE_ASSERT(!Allocator::isGarbageCollected, FinalizeOnHeapAllocatedListHashSetShouldNeverBeCalled);
         deleteAllNodes();
     }
 
     template<typename T, size_t inlineCapacity, typename U, typename V>
-    inline T& ListHashSet<T, inlineCapacity, U, V>::first()
+    T& ListHashSet<T, inlineCapacity, U, V>::first()
     {
         ASSERT(!isEmpty());
         return m_head->m_value;
     }
 
     template<typename T, size_t inlineCapacity, typename U, typename V>
-    inline void ListHashSet<T, inlineCapacity, U, V>::removeFirst()
+    void ListHashSet<T, inlineCapacity, U, V>::removeFirst()
     {
         ASSERT(!isEmpty());
         m_impl.remove(m_head);
         unlinkAndDelete(m_head);
     }
 
     template<typename T, size_t inlineCapacity, typename U, typename V>
-    inline const T& ListHashSet<T, inlineCapacity, U, V>::first() const
+    const T& ListHashSet<T, inlineCapacity, U, V>::first() const
     {
         ASSERT(!isEmpty());
         return m_head->m_value;
     }
 
     template<typename T, size_t inlineCapacity, typename U, typename V>
-    inline T& ListHashSet<T, inlineCapacity, U, V>::last()
+    T& ListHashSet<T, inlineCapacity, U, V>::last()
     {
         ASSERT(!isEmpty());
         return m_tail->m_value;
     }
 
     template<typename T, size_t inlineCapacity, typename U, typename V>
-    inline const T& ListHashSet<T, inlineCapacity, U, V>::last() const
+    const T& ListHashSet<T, inlineCapacity, U, V>::last() const
     {
         ASSERT(!isEmpty());
         return m_tail->m_value;
     }
 
     template<typename T, size_t inlineCapacity, typename U, typename V>
-    inline void ListHashSet<T, inlineCapacity, U, V>::removeLast()
+    void ListHashSet<T, inlineCapacity, U, V>::removeLast()
     {
         ASSERT(!isEmpty());
         m_impl.remove(m_tail);
         unlinkAndDelete(m_tail);
     }
 
     template<typename T, size_t inlineCapacity, typename U, typename V>
-    inline typename ListHashSet<T, inlineCapacity, U, V>::iterator ListHashSet<T, inlineCapacity, U, V>::find(ValuePeekInType value)
+    typename ListHashSet<T, inlineCapacity, U, V>::iterator ListHashSet<T, inlineCapacity, U, V>::find(ValuePeekInType value)
     {
         ImplTypeIterator it = m_impl.template find<BaseTranslator>(value);
         if (it == m_impl.end())
             return end();
         return makeIterator(*it);
     }
 
     template<typename T, size_t inlineCapacity, typename U, typename V>
-    inline typename ListHashSet<T, inlineCapacity, U, V>::const_iterator ListHashSet<T, inlineCapacity, U, V>::find(ValuePeekInType value) const
+    typename ListHashSet<T, inlineCapacity, U, V>::const_iterator ListHashSet<T, inlineCapacity, U, V>::find(ValuePeekInType value) const
     {
         ImplTypeConstIterator it = m_impl.template find<BaseTranslator>(value);
         if (it == m_impl.end())
             return end();
         return makeConstIterator(*it);
     }
 
     template<typename Translator>
     struct ListHashSetTranslatorAdapter {
         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->m_value, b); }
     };
 
     template<typename ValueType, size_t inlineCapacity, typename U, typename V>
     template<typename HashTranslator, typename T>
-    inline typename ListHashSet<ValueType, inlineCapacity, U, V>::iterator ListHashSet<ValueType, inlineCapacity, U, V>::find(const T& value)
+    typename ListHashSet<ValueType, inlineCapacity, U, V>::iterator ListHashSet<ValueType, inlineCapacity, U, V>::find(const T& value)
     {
         ImplTypeConstIterator it = m_impl.template find<ListHashSetTranslatorAdapter<HashTranslator> >(value);
         if (it == m_impl.end())
             return end();
         return makeIterator(*it);
     }
 
     template<typename ValueType, size_t inlineCapacity, typename U, typename V>
     template<typename HashTranslator, typename T>
-    inline typename ListHashSet<ValueType, inlineCapacity, U, V>::const_iterator ListHashSet<ValueType, inlineCapacity, U, V>::find(const T& value) const
+    typename ListHashSet<ValueType, inlineCapacity, U, V>::const_iterator ListHashSet<ValueType, inlineCapacity, U, V>::find(const T& value) const
     {
         ImplTypeConstIterator it = m_impl.template find<ListHashSetTranslatorAdapter<HashTranslator> >(value);
         if (it == m_impl.end())
             return end();
         return makeConstIterator(*it);
     }
 
     template<typename ValueType, size_t inlineCapacity, typename U, typename V>
     template<typename HashTranslator, typename T>
-    inline bool ListHashSet<ValueType, inlineCapacity, U, V>::contains(const T& value) const
+    bool ListHashSet<ValueType, inlineCapacity, U, V>::contains(const T& value) const
     {
         return m_impl.template contains<ListHashSetTranslatorAdapter<HashTranslator> >(value);
     }
 
     template<typename T, size_t inlineCapacity, typename U, typename V>
-    inline bool ListHashSet<T, inlineCapacity, U, V>::contains(ValuePeekInType value) const
+    bool ListHashSet<T, inlineCapacity, U, V>::contains(ValuePeekInType value) const
     {
         return m_impl.template contains<BaseTranslator>(value);
     }
 
     template<typename T, size_t inlineCapacity, typename U, typename V>
     typename ListHashSet<T, inlineCapacity, U, V>::AddResult ListHashSet<T, inlineCapacity, U, V>::add(ValuePassInType value)
     {
         createAllocatorIfNeeded();
         // The second argument is a const ref. This is useful for the HashTable
         // because it lets it take lvalues by reference, but for our purposes
@@ skipping 46 matching lines @@
     }
 
     template<typename T, size_t inlineCapacity, typename U, typename V>
     typename ListHashSet<T, inlineCapacity, U, V>::AddResult ListHashSet<T, inlineCapacity, U, V>::insertBefore(ValuePeekInType beforeValue, ValuePassInType newValue)
     {
         createAllocatorIfNeeded();
         return insertBefore(find(beforeValue), newValue);
     }
 
     template<typename T, size_t inlineCapacity, typename U, typename V>
-    inline void ListHashSet<T, inlineCapacity, U, V>::remove(iterator it)
+    void ListHashSet<T, inlineCapacity, U, V>::remove(iterator it)
     {
         if (it == end())
             return;
         m_impl.remove(it.node());
         unlinkAndDelete(it.node());
     }
 
     template<typename T, size_t inlineCapacity, typename U, typename V>
-    inline void ListHashSet<T, inlineCapacity, U, V>::clear()
+    void ListHashSet<T, inlineCapacity, U, V>::clear()
     {
         deleteAllNodes();
         m_impl.clear();
         m_head = 0;
         m_tail = 0;
     }
 
     template<typename T, size_t inlineCapacity, typename U, typename V>
     typename ListHashSet<T, inlineCapacity, U, V>::ValuePassOutType ListHashSet<T, inlineCapacity, U, V>::take(iterator it)
     {
@@ skipping 123 matching lines @@
     struct NeedsTracing<ListHashSet<T, U, V> > {
         static const bool value = false;
     };
 #endif
 
 } // namespace WTF
 
 using WTF::ListHashSet;
 
 #endif /* WTF_ListHashSet_h */