Changeset 12328 in webkit for trunk/JavaScriptCore


Ignore:
Timestamp:
Jan 23, 2006, 10:24:11 PM (19 years ago)
Author:
mjs
Message:

Reviewed by Tim Omernick.


  • kjs/array_object.cpp:
  • kjs/identifier.cpp:
  • kjs/internal.cpp:
  • kxmlcore/HashMap.h: (KXMLCore::PairFirstExtractor::extract):
  • kxmlcore/HashMapPtrSpec.h: (KXMLCore::):
  • kxmlcore/HashSet.h: (KXMLCore::IdentityExtractor::extract):
  • kxmlcore/HashTable.h: (KXMLCore::addIterator): (KXMLCore::removeIterator): (KXMLCore::HashTable::add): (KXMLCore::HashTable::isEmptyBucket): (KXMLCore::HashTable::isDeletedBucket): (KXMLCore::HashTable::HashTable): (KXMLCore::HashTable::lookup): (KXMLCore::HashTable::add): (KXMLCore::HashTable::reinsert): (KXMLCore::HashTable::find): (KXMLCore::HashTable::contains): (KXMLCore::HashTable::remove): (KXMLCore::HashTable::allocateTable): (KXMLCore::HashTable::deallocateTable): (KXMLCore::HashTable::expand): (KXMLCore::HashTable::rehash): (KXMLCore::HashTable::clear): (KXMLCore::HashTable::swap): (KXMLCore::HashTable::operator): (KXMLCore::HashTable::checkTableConsistency): (KXMLCore::HashTable::checkTableConsistencyExceptSize): (KXMLCore::HashTable::invalidateIterators):
Location:
trunk/JavaScriptCore
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/ChangeLog

    r12321 r12328  
     12006-01-23  Maciej Stachowiak  <[email protected]>
     2
     3        Reviewed by Tim Omernick.
     4       
     5        - use classes instead of free functions for extractors, this better matches how other
     6        things work and should avoid the need for hacky workarounds on other compilers
     7        http://bugzilla.opendarwin.org/show_bug.cgi?id=6748
     8
     9        * kjs/array_object.cpp:
     10        * kjs/identifier.cpp:
     11        * kjs/internal.cpp:
     12        * kxmlcore/HashMap.h:
     13        (KXMLCore::PairFirstExtractor::extract):
     14        * kxmlcore/HashMapPtrSpec.h:
     15        (KXMLCore::):
     16        * kxmlcore/HashSet.h:
     17        (KXMLCore::IdentityExtractor::extract):
     18        * kxmlcore/HashTable.h:
     19        (KXMLCore::addIterator):
     20        (KXMLCore::removeIterator):
     21        (KXMLCore::HashTable::add):
     22        (KXMLCore::HashTable::isEmptyBucket):
     23        (KXMLCore::HashTable::isDeletedBucket):
     24        (KXMLCore::HashTable::HashTable):
     25        (KXMLCore::HashTable::lookup):
     26        (KXMLCore::HashTable::add):
     27        (KXMLCore::HashTable::reinsert):
     28        (KXMLCore::HashTable::find):
     29        (KXMLCore::HashTable::contains):
     30        (KXMLCore::HashTable::remove):
     31        (KXMLCore::HashTable::allocateTable):
     32        (KXMLCore::HashTable::deallocateTable):
     33        (KXMLCore::HashTable::expand):
     34        (KXMLCore::HashTable::rehash):
     35        (KXMLCore::HashTable::clear):
     36        (KXMLCore::HashTable::swap):
     37        (KXMLCore::HashTable::operator):
     38        (KXMLCore::HashTable::checkTableConsistency):
     39        (KXMLCore::HashTable::checkTableConsistencyExceptSize):
     40        (KXMLCore::HashTable::invalidateIterators):
     41
    1422006-01-23  Maciej Stachowiak  <[email protected]>
    243

  • trunk/JavaScriptCore/kjs/array_object.cpp

    r12321 r12328  
    3939#include <stdio.h>
    4040#include <assert.h>
    41 
    42 #ifdef WIN32
    43 template class KJS::JSObject * const & KXMLCore::identityExtract<class KJS::JSObject *>(class KJS::JSObject * const &);
    44 #endif
    4541
    4642using namespace KJS;

  • trunk/JavaScriptCore/kjs/identifier.cpp

    r12321 r12328  
    4141#include <string.h> // for strlen
    4242#include <new> // for placement new
    43 
    44 #ifdef WIN32
    45 template struct KJS::UString::Rep * const & KXMLCore::identityExtract<struct KJS::UString::Rep *>(struct KJS::UString::Rep * const &);
    46 #endif
    4743
    4844namespace KXMLCore {

  • trunk/JavaScriptCore/kjs/internal.cpp

    r12317 r12328  
    4646#include <math.h>
    4747#include <stdio.h>
    48 
    49 #if WIN32
    50 #include <float.h>
    51 #define copysign(a, b) _copysign(a, b)
    52 template void * const & KXMLCore::extractFirst<struct std::pair<void *,void *> >(struct std::pair<void *, void *> const &);
    53 #endif
    5448
    5549extern int kjsyyparse();

  • trunk/JavaScriptCore/kxmlcore/HashMap.h

    r12321 r12328  
    3030namespace KXMLCore {
    3131
    32 template<typename PairType>
    33 inline typename PairType::first_type const& extractFirst(const PairType& value)
    34 {
    35     return value.first;
    36 }
     32template<typename Key, typename Mapped>
     33class PairFirstExtractor
     34{
     35    typedef pair<Key, Mapped> ValueType;
     36       
     37public:
     38    static const Key& extract(const ValueType& value)
     39    {
     40        return value.first;
     41    }
     42};
    3743
    3844template<typename Key, typename Mapped, typename HashFunctions>
    … …  
    6874    typedef PairHashTraits<KeyTraits, MappedTraits> ValueTraits;
    6975 private:
    70     typedef HashTable<KeyType, ValueType, extractFirst<ValueType>, HashFunctions, ValueTraits, KeyTraits> ImplType;
     76    typedef HashTable<KeyType, ValueType, PairFirstExtractor<KeyType, MappedType>, HashFunctions, ValueTraits, KeyTraits> ImplType;
    7177    typedef HashMapTranslator<Key, Mapped, HashFunctions> TranslatorType;
    7278 public:

  • trunk/JavaScriptCore/kxmlcore/HashMapPtrSpec.h

    r12301 r12328  
    181181        typedef std::pair<KeyType, MappedType> ValueType;
    182182        typedef typename std::pair<void *, void *> ImplValueType;
    183         typedef HashTableIterator<void *, ImplValueType, extractFirst<ImplValueType>, DefaultHash<void *>, PairHashTraits<HashTraits<void *>, HashTraits<void *> >, HashTraits<void *> > ImplIterator;
    184         typedef HashTableConstIterator<void *, ImplValueType, extractFirst<ImplValueType>, DefaultHash<void *>, PairHashTraits<HashTraits<void *>, HashTraits<void *> >, HashTraits<void *> > ImplConstIterator;
     183        typedef HashTableIterator<void *, ImplValueType, PairFirstExtractor<void *, void*>, DefaultHash<void *>, PairHashTraits<HashTraits<void *>, HashTraits<void *> >, HashTraits<void *> > ImplIterator;
     184        typedef HashTableConstIterator<void *, ImplValueType, PairFirstExtractor<void *, void*>, DefaultHash<void *>, PairHashTraits<HashTraits<void *>, HashTraits<void *> >, HashTraits<void *> > ImplConstIterator;
    185185       
    186186        typedef PointerHashIteratorAdapter<P, Q *> iterator;

  • trunk/JavaScriptCore/kxmlcore/HashSet.h

    r12321 r12328  
    3131
    3232    template <typename T>
    33     inline const T& identityExtract(const T& t)
    34     {
    35         return t;
    36     }
    37 
     33    struct IdentityExtractor
     34    {
     35        static const T& extract(const T& t)
     36        {
     37            return t;
     38        }
     39    };
    3840
    3941    template<typename Value, typename T, typename HashSetTranslator>
    … …  
    5961    class HashSet {
    6062    private:
    61         typedef HashTable<Value, Value, identityExtract<Value>, HashFunctions, Traits, Traits> ImplType;
     63        typedef HashTable<Value, Value, IdentityExtractor<Value>, HashFunctions, Traits, Traits> ImplType;
    6264    public:
    6365        typedef Value ValueType;

  • trunk/JavaScriptCore/kxmlcore/HashTable.h

    r12321 r12328  
    5656#endif
    5757
    58     template<typename Key, typename Value, const Key& ExtractKey(const Value&), typename HashFunctions, typename Traits, typename KeyTraits>
     58    template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits>
    5959    class HashTable;
    60     template<typename Key, typename Value, const Key& ExtractKey(const Value&), typename HashFunctions, typename Traits, typename KeyTraits>
     60    template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits>
    6161    class HashTableIterator;
    62     template<typename Key, typename Value, const Key& ExtractKey(const Value&), typename HashFunctions, typename Traits, typename KeyTraits>
     62    template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits>
    6363    class HashTableConstIterator;
    6464
    6565#if CHECK_HASHTABLE_ITERATORS
    66     template<typename Key, typename Value, const Key& ExtractKey(const Value&), typename HashFunctions, typename Traits, typename KeyTraits>
    67     void addIterator(const HashTable<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits>*,
    68         HashTableConstIterator<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits>*);
    69 
    70     template<typename Key, typename Value, const Key& ExtractKey(const Value&), typename HashFunctions, typename Traits, typename KeyTraits>
    71     void removeIterator(HashTableConstIterator<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits>*);
     66    template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits>
     67    void addIterator(const HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits>*,
     68        HashTableConstIterator<Key, Value, Extractor, HashFunctions, Traits, KeyTraits>*);
     69
     70    template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits>
     71    void removeIterator(HashTableConstIterator<Key, Value, Extractor, HashFunctions, Traits, KeyTraits>*);
    7272#else
    73     template<typename Key, typename Value, const Key& ExtractKey(const Value&), typename HashFunctions, typename Traits, typename KeyTraits>
    74     inline void addIterator(const HashTable<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits>*,
    75         HashTableConstIterator<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits>*) { }
    76 
    77     template<typename Key, typename Value, const Key& ExtractKey(const Value&), typename HashFunctions, typename Traits, typename KeyTraits>
    78     inline void removeIterator(HashTableConstIterator<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits>*) { }
    79 #endif
    80 
    81     template<typename Key, typename Value, const Key& ExtractKey(const Value&), typename HashFunctions, typename Traits, typename KeyTraits>
     73    template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits>
     74    inline void addIterator(const HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits>*,
     75        HashTableConstIterator<Key, Value, Extractor, HashFunctions, Traits, KeyTraits>*) { }
     76
     77    template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits>
     78    inline void removeIterator(HashTableConstIterator<Key, Value, Extractor, HashFunctions, Traits, KeyTraits>*) { }
     79#endif
     80
     81    template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits>
    8282    class HashTableConstIterator {
    8383    private:
    84         typedef HashTable<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits> HashTableType;
    85         typedef HashTableIterator<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits> iterator;
    86         typedef HashTableConstIterator<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits> const_iterator;
     84        typedef HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits> HashTableType;
     85        typedef HashTableIterator<Key, Value, Extractor, HashFunctions, Traits, KeyTraits> iterator;
     86        typedef HashTableConstIterator<Key, Value, Extractor, HashFunctions, Traits, KeyTraits> const_iterator;
    8787        typedef Value ValueType;
    8888        typedef const ValueType& ReferenceType;
    8989        typedef const ValueType* PointerType;
    9090
    91         friend class HashTable<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits>;
    92         friend class HashTableIterator<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits>;
     91        friend class HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits>;
     92        friend class HashTableIterator<Key, Value, Extractor, HashFunctions, Traits, KeyTraits>;
    9393
    9494        void skipEmptyBuckets()
    … …  
    203203    };
    204204
    205     template<typename Key, typename Value, const Key& ExtractKey(const Value&), typename HashFunctions, typename Traits, typename KeyTraits>
     205    template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits>
    206206    class HashTableIterator {
    207207    private:
    208         typedef HashTable<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits> HashTableType;
    209         typedef HashTableIterator<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits> iterator;
    210         typedef HashTableConstIterator<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits> const_iterator;
     208        typedef HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits> HashTableType;
     209        typedef HashTableIterator<Key, Value, Extractor, HashFunctions, Traits, KeyTraits> iterator;
     210        typedef HashTableConstIterator<Key, Value, Extractor, HashFunctions, Traits, KeyTraits> const_iterator;
    211211        typedef Value ValueType;
    212212        typedef ValueType& ReferenceType;
    213213        typedef ValueType* PointerType;
    214214
    215         friend class HashTable<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits>;
     215        friend class HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits>;
    216216
    217217        HashTableIterator(HashTableType* table, PointerType pos, PointerType end) : m_iterator(table, pos, end) { }
    … …  
    261261    };
    262262
    263     template<typename Key, typename Value, const Key& ExtractKey(const Value&), typename HashFunctions, typename Traits, typename KeyTraits>
     263    template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits>
    264264    class HashTable {
    265265    public:
    266         typedef HashTableIterator<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits> iterator;
    267         typedef HashTableConstIterator<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits> const_iterator;
     266        typedef HashTableIterator<Key, Value, Extractor, HashFunctions, Traits, KeyTraits> iterator;
     267        typedef HashTableConstIterator<Key, Value, Extractor, HashFunctions, Traits, KeyTraits> const_iterator;
    268268        typedef Key KeyType;
    269269        typedef Value ValueType;
    … …  
    285285        int capacity() const { return m_tableSize; }
    286286
    287         pair<iterator, bool> add(const ValueType& value) { return add<KeyType, ValueType, IdentityTranslatorType>(ExtractKey(value), value); }
     287        pair<iterator, bool> add(const ValueType& value) { return add<KeyType, ValueType, IdentityTranslatorType>(Extractor::extract(value), value); }
    288288
    289289        // A special version of add() that finds the object by hashing and comparing
    … …  
    300300        void clear();
    301301
    302         static bool isEmptyBucket(const ValueType& value) { return ExtractKey(value) == KeyTraits::emptyValue(); }
    303         static bool isDeletedBucket(const ValueType& value) { return ExtractKey(value) == KeyTraits::deletedValue(); }
     302        static bool isEmptyBucket(const ValueType& value) { return Extractor::extract(value) == KeyTraits::emptyValue(); }
     303        static bool isDeletedBucket(const ValueType& value) { return Extractor::extract(value) == KeyTraits::deletedValue(); }
    304304        static bool isEmptyOrDeletedBucket(const ValueType& value) { return isEmptyBucket(value) || isDeletedBucket(value); }
    305305
    … …  
    364364    };
    365365
    366     template<typename Key, typename Value, const Key& ExtractKey(const Value&), typename HashFunctions, typename Traits, typename KeyTraits>
    367     inline HashTable<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits>::HashTable()
     366    template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits>
     367    inline HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits>::HashTable()
    368368        : m_table(0)
    369369        , m_tableSize(0)
    … …  
    377377    }
    378378
    379     template<typename Key, typename Value, const Key& ExtractKey(const Value&), typename HashFunctions, typename Traits, typename KeyTraits>
     379    template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits>
    380380    template<typename T, typename HashTranslator>
    381     inline typename HashTable<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits>::FullLookupType HashTable<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits>::lookup(const T& key)
     381    inline typename HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits>::FullLookupType HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits>::lookup(const T& key)
    382382    {
    383383        assert(m_table);
    … …  
    399399            if (isDeletedBucket(*entry))
    400400                deletedEntry = entry;
    401             else if (HashTranslator::equal(ExtractKey(*entry), key))
     401            else if (HashTranslator::equal(Extractor::extract(*entry), key))
    402402                return makeLookupResult(entry, true, h);
    403403#if DUMP_HASHTABLE_STATS
    … …  
    414414
    415415
    416     template<typename Key, typename Value, const Key& ExtractKey(const Value&), typename HashFunctions, typename Traits, typename KeyTraits>
     416    template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits>
    417417    template<typename T, typename Extra, typename HashTranslator>
    418     inline pair<typename HashTable<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits>::iterator, bool> HashTable<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits>::add(const T& key, const Extra &extra)
     418    inline pair<typename HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits>::iterator, bool> HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits>::add(const T& key, const Extra &extra)
    419419    {
    420420        invalidateIterators();
    … …  
    444444            // expand is rare, but would be better to have a version of expand that can
    445445            // follow a pivot entry and return the new position
    446             KeyType enteredKey = ExtractKey(*entry);
     446            KeyType enteredKey = Extractor::extract(*entry);
    447447            expand();
    448448            return std::make_pair(find(enteredKey), true);
    … …  
    454454    }
    455455
    456     template<typename Key, typename Value, const Key& ExtractKey(const Value&), typename HashFunctions, typename Traits, typename KeyTraits>
    457     inline void HashTable<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits>::reinsert(ValueType& entry)
     456    template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits>
     457    inline void HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits>::reinsert(ValueType& entry)
    458458    {
    459459        assert(m_table);
    460         assert(!lookup(ExtractKey(entry)).second);
    461         assert(!isDeletedBucket(*(lookup(ExtractKey(entry)).first)));
     460        assert(!lookup(Extractor::extract(entry)).second);
     461        assert(!isDeletedBucket(*(lookup(Extractor::extract(entry)).first)));
    462462#if DUMP_HASHTABLE_STATS
    463463        ++HashTableStats::numReinserts;
    464464#endif
    465465
    466         Mover<ValueType, Traits::needsDestruction>::move(entry, *(lookup(ExtractKey(entry)).first));
    467     }
    468 
    469     template<typename Key, typename Value, const Key& ExtractKey(const Value&), typename HashFunctions, typename Traits, typename KeyTraits>
    470     inline typename HashTable<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits>::iterator HashTable<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits>::find(const Key& key)
     466        Mover<ValueType, Traits::needsDestruction>::move(entry, *(lookup(Extractor::extract(entry)).first));
     467    }
     468
     469    template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits>
     470    inline typename HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits>::iterator HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits>::find(const Key& key)
    471471    {
    472472        if (!m_table)
    … …  
    479479    }
    480480
    481     template<typename Key, typename Value, const Key& ExtractKey(const Value&), typename HashFunctions, typename Traits, typename KeyTraits>
    482     inline typename HashTable<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits>::const_iterator HashTable<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits>::find(const Key& key) const
     481    template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits>
     482    inline typename HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits>::const_iterator HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits>::find(const Key& key) const
    483483    {
    484484        if (!m_table)
    … …  
    491491    }
    492492
    493     template<typename Key, typename Value, const Key& ExtractKey(const Value&), typename HashFunctions, typename Traits, typename KeyTraits>
    494     inline bool HashTable<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits>::contains(const KeyType& key) const
     493    template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits>
     494    inline bool HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits>::contains(const KeyType& key) const
    495495    {
    496496        if (!m_table)
    … …  
    500500    }
    501501
    502     template<typename Key, typename Value, const Key& ExtractKey(const Value&), typename HashFunctions, typename Traits, typename KeyTraits>
    503     inline void HashTable<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits>::remove(ValueType* pos)
     502    template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits>
     503    inline void HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits>::remove(ValueType* pos)
    504504    {
    505505        invalidateIterators();
    … …  
    520520    }
    521521
    522     template<typename Key, typename Value, const Key& ExtractKey(const Value&), typename HashFunctions, typename Traits, typename KeyTraits>
    523     inline void HashTable<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits>::remove(const KeyType& key)
     522    template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits>
     523    inline void HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits>::remove(const KeyType& key)
    524524    {
    525525        if (!m_table)
    … …  
    529529    }
    530530
    531     template<typename Key, typename Value, const Key& ExtractKey(const Value&), typename HashFunctions, typename Traits, typename KeyTraits>
    532     inline void HashTable<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits>::remove(iterator it)
     531    template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits>
     532    inline void HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits>::remove(iterator it)
    533533    {
    534534        if (it == end())
    … …  
    539539
    540540
    541     template<typename Key, typename Value, const Key& ExtractKey(const Value&), typename HashFunctions, typename Traits, typename KeyTraits>
    542     inline Value *HashTable<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits>::allocateTable(int size)
     541    template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits>
     542    inline Value *HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits>::allocateTable(int size)
    543543    {
    544544        // would use a template member function with explicit specializations here, but
    … …  
    555555    }
    556556
    557     template<typename Key, typename Value, const Key& ExtractKey(const Value&), typename HashFunctions, typename Traits, typename KeyTraits>
    558     inline void HashTable<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits>::deallocateTable(ValueType *table, int size)
     557    template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits>
     558    inline void HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits>::deallocateTable(ValueType *table, int size)
    559559    {
    560560        if (Traits::needsDestruction) {
    … …  
    567567    }
    568568
    569     template<typename Key, typename Value, const Key& ExtractKey(const Value&), typename HashFunctions, typename Traits, typename KeyTraits>
    570     inline void HashTable<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits>::expand()
     569    template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits>
     570    inline void HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits>::expand()
    571571    {
    572572        int newSize;
    … …  
    581581    }
    582582
    583     template<typename Key, typename Value, const Key& ExtractKey(const Value&), typename HashFunctions, typename Traits, typename KeyTraits>
    584     void HashTable<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits>::rehash(int newTableSize)
     583    template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits>
     584    void HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits>::rehash(int newTableSize)
    585585    {
    586586        checkTableConsistencyExceptSize();
    … …  
    610610    }
    611611
    612     template<typename Key, typename Value, const Key& ExtractKey(const Value&), typename HashFunctions, typename Traits, typename KeyTraits>
    613     inline void HashTable<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits>::clear()
     612    template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits>
     613    inline void HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits>::clear()
    614614    {
    615615        invalidateIterators();
    … …  
    621621    }
    622622
    623     template<typename Key, typename Value, const Key& ExtractKey(const Value&), typename HashFunctions, typename Traits, typename KeyTraits>
    624     HashTable<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits>::HashTable(const HashTable& other)
     623    template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits>
     624    HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits>::HashTable(const HashTable& other)
    625625        : m_table(0)
    626626        , m_tableSize(0)
    … …  
    639639    }
    640640
    641     template<typename Key, typename Value, const Key& ExtractKey(const Value&), typename HashFunctions, typename Traits, typename KeyTraits>
    642     void HashTable<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits>::swap(HashTable& other)
     641    template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits>
     642    void HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits>::swap(HashTable& other)
    643643    {
    644644        invalidateIterators();
    … …  
    666666    }
    667667
    668     template<typename Key, typename Value, const Key& ExtractKey(const Value&), typename HashFunctions, typename Traits, typename KeyTraits>
    669     HashTable<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits>& HashTable<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits>::operator=(const HashTable& other)
     668    template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits>
     669    HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits>& HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits>::operator=(const HashTable& other)
    670670    {
    671671        HashTable tmp(other);
    … …  
    676676#if CHECK_HASHTABLE_CONSISTENCY
    677677
    678     template<typename Key, typename Value, const Key& ExtractKey(const Value&), typename HashFunctions, typename Traits, typename KeyTraits>
    679     void HashTable<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits>::checkTableConsistency() const
     678    template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits>
     679    void HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits>::checkTableConsistency() const
    680680    {
    681681        checkTableConsistencyExceptSize();
    … …  
    684684    }
    685685
    686     template<typename Key, typename Value, const Key& ExtractKey(const Value&), typename HashFunctions, typename Traits, typename KeyTraits>
    687     void HashTable<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits>::checkTableConsistencyExceptSize() const
     686    template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits>
     687    void HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits>::checkTableConsistencyExceptSize() const
    688688    {
    689689        if (!m_table)
    … …  
    702702            }
    703703
    704             const_iterator it = find(ExtractKey(*entry));
     704            const_iterator it = find(Extractor::extract(*entry));
    705705            assert(entry == it.m_position);
    706706            ++count;
    … …  
    718718#if CHECK_HASHTABLE_ITERATORS
    719719
    720     template<typename Key, typename Value, const Key& ExtractKey(const Value&), typename HashFunctions, typename Traits, typename KeyTraits>
    721     void HashTable<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits>::invalidateIterators()
     720    template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits>
     721    void HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits>::invalidateIterators()
    722722    {
    723723        const_iterator* next;
    … …  
    731731    }
    732732
    733     template<typename Key, typename Value, const Key& ExtractKey(const Value&), typename HashFunctions, typename Traits, typename KeyTraits>
    734     void addIterator(const HashTable<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits>* table,
    735         HashTableConstIterator<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits>* it)
     733    template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits>
     734    void addIterator(const HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits>* table,
     735        HashTableConstIterator<Key, Value, Extractor, HashFunctions, Traits, KeyTraits>* it)
    736736    {
    737737        it->m_table = table;
    … …  
    752752    }
    753753
    754     template<typename Key, typename Value, const Key& ExtractKey(const Value&), typename HashFunctions, typename Traits, typename KeyTraits>
    755     void removeIterator(HashTableConstIterator<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits>* it)
    756     {
    757         typedef HashTable<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits> HashTableType;
    758         typedef HashTableConstIterator<Key, Value, ExtractKey, HashFunctions, Traits, KeyTraits> const_iterator;
     754    template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits>
     755    void removeIterator(HashTableConstIterator<Key, Value, Extractor, HashFunctions, Traits, KeyTraits>* it)
     756    {
     757        typedef HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits> HashTableType;
     758        typedef HashTableConstIterator<Key, Value, Extractor, HashFunctions, Traits, KeyTraits> const_iterator;
    759759
    760760        // Delete iterator from doubly-linked list of iterators.
Note: See TracChangeset for help on using the changeset viewer.