Simpler return value of HashTable::add/HashMap:add and others

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 64 matching lines @@
         typedef ValueArg ValueType;
 
         typedef ListHashSetIterator<ValueType, inlineCapacity, HashArg> iterator;
         typedef ListHashSetConstIterator<ValueType, inlineCapacity, HashArg> const_iterator;
         friend class ListHashSetConstIterator<ValueType, inlineCapacity, HashArg>;
 
         typedef ListHashSetReverseIterator<ValueType, inlineCapacity, HashArg> reverse_iterator;
         typedef ListHashSetConstReverseIterator<ValueType, inlineCapacity, HashArg> const_reverse_iterator;
         friend class ListHashSetConstReverseIterator<ValueType, inlineCapacity, HashArg>;
 
-        typedef HashTableAddResult<iterator> AddResult;
+        template<typename ValueType> struct HashTableAddResult {
+        HashTableAddResult(Node* storedValue, bool isNewEntry) : storedValue(storedValue), isNewEntry(isNewEntry) { }
+            Node* storedValue;
+            bool isNewEntry;
+        };
+        typedef HashTableAddResult<ValueType> AddResult;
 
         ListHashSet();
         ListHashSet(const ListHashSet&);
         ListHashSet& operator=(const ListHashSet&);
         ~ListHashSet();
 
         void swap(ListHashSet&);
 
         unsigned size() const;
         unsigned capacity() const;
@@ skipping 23 matching lines @@
         const_iterator find(const ValueType&) const;
         bool contains(const ValueType&) const;
 
         // 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 an iterator to the new value's location,
+        // 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(const ValueType&);
 
+        // 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(const ValueType&);
+
         // 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(const ValueType&);
 
         // 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(const ValueType&);
 
         AddResult insertBefore(const ValueType& beforeValue, const ValueType& newValue);
         AddResult insertBefore(iterator, const ValueType&);
@@ skipping 585 matching lines @@
     {
         return m_impl.template contains<BaseTranslator>(value);
     }
 
     template<typename T, size_t inlineCapacity, typename U>
     typename ListHashSet<T, inlineCapacity, U>::AddResult ListHashSet<T, inlineCapacity, U>::add(const ValueType &value)
     {
         createAllocatorIfNeeded();
         typename ImplType::AddResult result = m_impl.template add<BaseTranslator>(value, m_allocator.get());
         if (result.isNewEntry)
-            appendNode(*result.iterator);
-        return AddResult(makeIterator(*result.iterator), result.isNewEntry);
+            appendNode(*result.storedValue);
+        return AddResult(*result.storedValue, result.isNewEntry);
     }
 
     template<typename T, size_t inlineCapacity, typename U>
+    typename ListHashSet<T, inlineCapacity, U>::iterator ListHashSet<T, inlineCapacity, U>::addReturnIterator(const ValueType &value)
+    {
+        return makeIterator(add(value).storedValue);
+    }
+    template<typename T, size_t inlineCapacity, typename U>
     typename ListHashSet<T, inlineCapacity, U>::AddResult ListHashSet<T, inlineCapacity, U>::appendOrMoveToLast(const ValueType &value)
     {
         createAllocatorIfNeeded();
         typename ImplType::AddResult result = m_impl.template add<BaseTranslator>(value, m_allocator.get());
-        Node* node = *result.iterator;
+        Node* node = *result.storedValue;
         if (!result.isNewEntry)
             unlink(node);
         appendNode(node);
-        return AddResult(makeIterator(*result.iterator), result.isNewEntry);
+        return AddResult(*result.storedValue, result.isNewEntry);
     }
 
     template<typename T, size_t inlineCapacity, typename U>
     typename ListHashSet<T, inlineCapacity, U>::AddResult ListHashSet<T, inlineCapacity, U>::prependOrMoveToFirst(const ValueType &value)
     {
         createAllocatorIfNeeded();
         typename ImplType::AddResult result = m_impl.template add<BaseTranslator>(value, m_allocator.get());
-        Node* node = *result.iterator;
+        Node* node = *result.storedValue;
         if (!result.isNewEntry)
             unlink(node);
         prependNode(node);
-        return AddResult(makeIterator(*result.iterator), result.isNewEntry);
+        return AddResult(*result.storedValue, result.isNewEntry);
     }
 
     template<typename T, size_t inlineCapacity, typename U>
     typename ListHashSet<T, inlineCapacity, U>::AddResult ListHashSet<T, inlineCapacity, U>::insertBefore(iterator it, const ValueType& newValue)
     {
         createAllocatorIfNeeded();
         typename ImplType::AddResult result = m_impl.template add<BaseTranslator>(newValue, m_allocator.get());
         if (result.isNewEntry)
-            insertNodeBefore(it.node(), *result.iterator);
-        return AddResult(makeIterator(*result.iterator), result.isNewEntry);
+            insertNodeBefore(it.node(), *result.storedValue);
+        return AddResult(*result.storedValue, result.isNewEntry);
     }
 
     template<typename T, size_t inlineCapacity, typename U>
     typename ListHashSet<T, inlineCapacity, U>::AddResult ListHashSet<T, inlineCapacity, U>::insertBefore(const ValueType& beforeValue, const ValueType& newValue)
     {
         createAllocatorIfNeeded();
         return insertBefore(find(beforeValue), newValue);
     }
 
     template<typename T, size_t inlineCapacity, typename U>
@@ skipping 147 matching lines @@
     inline void deleteAllValues(const ListHashSet<T, inlineCapacity, U>& collection)
     {
         deleteAllValues<true, typename ListHashSet<T, inlineCapacity, U>::ValueType>(collection.m_impl);
     }
 
 } // namespace WTF
 
 using WTF::ListHashSet;
 
 #endif /* WTF_ListHashSet_h */