Changeset 225751 in webkit


Ignore:
Timestamp:
Dec 11, 2017 11:22:01 AM (6 years ago)
Author:
Yusuke Suzuki
Message:

[WTF] Add Converter traits to StringHasher instead of function pointer
​https://bugs.webkit.org/show_bug.cgi?id=180656

Reviewed by JF Bastien.

Source/WebKit:

  • WebProcess/WebProcess.cpp:

(WebKit::addCaseFoldedCharacters):

Source/WTF:

In the latest ICU, UChar is char16_t. So defining defaultConverter(UChar)
and defaultConverter(char16_t) causes duplicate definitions.
Instead of passing a funtion pointer, we pass a trait class DefaultConveter
which has convert static function. And we make this convert function
generic. This avoids defining convert function for UChar and char16_t.

  • wtf/text/StringHash.h:

(WTF::ASCIICaseInsensitiveHash::FoldCase::convert):
(WTF::ASCIICaseInsensitiveHash::hash):
(WTF::ASCIICaseInsensitiveHash::foldCase): Deleted.

  • wtf/text/StringHasher.h:

(WTF::StringHasher::DefaultConverter::convert):
(WTF::StringHasher::addCharactersAssumingAligned):
(WTF::StringHasher::addCharacters):
(WTF::StringHasher::computeHashAndMaskTop8Bits):
(WTF::StringHasher::computeHash):
(WTF::StringHasher::computeLiteralHash):
(WTF::StringHasher::computeLiteralHashAndMaskTop8Bits):
(WTF::StringHasher::computeHashImpl):
(WTF::StringHasher::Converter): Deleted.
(WTF::StringHasher::defaultConverter): Deleted.

Location:
trunk/Source
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WTF/ChangeLog

    r225735 r225751  
     12017-12-11  Yusuke Suzuki  <utatane.tea@gmail.com>
     2
     3        [WTF] Add Converter traits to StringHasher instead of function pointer
     4        https://bugs.webkit.org/show_bug.cgi?id=180656
     5
     6        Reviewed by JF Bastien.
     7
     8        In the latest ICU, UChar is char16_t. So defining defaultConverter(UChar)
     9        and defaultConverter(char16_t) causes duplicate definitions.
     10        Instead of passing a funtion pointer, we pass a trait class DefaultConveter
     11        which has `convert` static function. And we make this `convert` function
     12        generic. This avoids defining convert function for UChar and char16_t.
     13
     14        * wtf/text/StringHash.h:
     15        (WTF::ASCIICaseInsensitiveHash::FoldCase::convert):
     16        (WTF::ASCIICaseInsensitiveHash::hash):
     17        (WTF::ASCIICaseInsensitiveHash::foldCase): Deleted.
     18        * wtf/text/StringHasher.h:
     19        (WTF::StringHasher::DefaultConverter::convert):
     20        (WTF::StringHasher::addCharactersAssumingAligned):
     21        (WTF::StringHasher::addCharacters):
     22        (WTF::StringHasher::computeHashAndMaskTop8Bits):
     23        (WTF::StringHasher::computeHash):
     24        (WTF::StringHasher::computeLiteralHash):
     25        (WTF::StringHasher::computeLiteralHashAndMaskTop8Bits):
     26        (WTF::StringHasher::computeHashImpl):
     27        (WTF::StringHasher::Converter): Deleted.
     28        (WTF::StringHasher::defaultConverter): Deleted.
     29
    1302017-12-10  Yusuke Suzuki  <utatane.tea@gmail.com>
    231

  • trunk/Source/WTF/wtf/text/StringHash.h

    r225463 r225751  
    8181
    8282    struct ASCIICaseInsensitiveHash {
    83         template<typename T> static inline UChar foldCase(T character)
    84         {
    85             return toASCIILower(character);
    86         }
     83        template<typename T>
     84        struct FoldCase {
     85            static inline UChar convert(T character)
     86            {
     87                return toASCIILower(character);
     88            }
     89        };
    8790
    8891        static unsigned hash(const UChar* data, unsigned length)
    8992        {
    90             return StringHasher::computeHashAndMaskTop8Bits<UChar, foldCase<UChar>>(data, length);
     93            return StringHasher::computeHashAndMaskTop8Bits<UChar, FoldCase<UChar>>(data, length);
    9194        }
    9295
    … …  
    105108        static unsigned hash(const LChar* data, unsigned length)
    106109        {
    107             return StringHasher::computeHashAndMaskTop8Bits<LChar, foldCase<LChar>>(data, length);
     110            return StringHasher::computeHashAndMaskTop8Bits<LChar, FoldCase<LChar>>(data, length);
    108111        }
    109112

  • trunk/Source/WTF/wtf/text/StringHasher.h

    r225730 r225751  
    4343    static constexpr const unsigned maskHash = (1U << (sizeof(unsigned) * 8 - flagCount)) - 1;
    4444
     45    struct DefaultConverter {
     46        template<typename CharType>
     47        static constexpr UChar convert(CharType character)
     48        {
     49            return static_cast<std::make_unsigned_t<CharType>>((character));
     50        }
     51    };
     52
    4553    StringHasher() = default;
    4654
    … …  
    8391    }
    8492
    85     template<typename T, UChar Converter(T)> void addCharactersAssumingAligned(const T* data, unsigned length)
     93    template<typename T, typename Converter> void addCharactersAssumingAligned(const T* data, unsigned length)
    8694    {
    8795        ASSERT(!m_hasPendingCharacter);
    … …  
    9199
    92100        while (length--) {
    93             addCharactersAssumingAligned(Converter(data[0]), Converter(data[1]));
     101            addCharactersAssumingAligned(Converter::convert(data[0]), Converter::convert(data[1]));
    94102            data += 2;
    95103        }
    96104
    97105        if (remainder)
    98             addCharacter(Converter(*data));
     106            addCharacter(Converter::convert(*data));
    99107    }
    100108
    101109    template<typename T> void addCharactersAssumingAligned(const T* data, unsigned length)
    102110    {
    103         addCharactersAssumingAligned<T, defaultConverter>(data, length);
    104     }
    105 
    106     template<typename T, UChar Converter(T)> void addCharactersAssumingAligned(const T* data)
     111        addCharactersAssumingAligned<T, DefaultConverter>(data, length);
     112    }
     113
     114    template<typename T, typename Converter> void addCharactersAssumingAligned(const T* data)
    107115    {
    108116        ASSERT(!m_hasPendingCharacter);
    … …  
    111119            T b = *data++;
    112120            if (!b) {
    113                 addCharacter(Converter(a));
     121                addCharacter(Converter::convert(a));
    114122                break;
    115123            }
    116             addCharactersAssumingAligned(Converter(a), Converter(b));
     124            addCharactersAssumingAligned(Converter::convert(a), Converter::convert(b));
    117125        }
    118126    }
    … …  
    120128    template<typename T> void addCharactersAssumingAligned(const T* data)
    121129    {
    122         addCharactersAssumingAligned<T, defaultConverter>(data);
    123     }
    124 
    125     template<typename T, UChar Converter(T)> void addCharacters(const T* data, unsigned length)
     130        addCharactersAssumingAligned<T, DefaultConverter>(data);
     131    }
     132
     133    template<typename T, typename Converter> void addCharacters(const T* data, unsigned length)
    126134    {
    127135        if (!length)
    … …  
    129137        if (m_hasPendingCharacter) {
    130138            m_hasPendingCharacter = false;
    131             addCharactersAssumingAligned(m_pendingCharacter, Converter(*data++));
     139            addCharactersAssumingAligned(m_pendingCharacter, Converter::convert(*data++));
    132140            --length;
    133141        }
    … …  
    137145    template<typename T> void addCharacters(const T* data, unsigned length)
    138146    {
    139         addCharacters<T, defaultConverter>(data, length);
    140     }
    141 
    142     template<typename T, UChar Converter(T)> void addCharacters(const T* data)
     147        addCharacters<T, DefaultConverter>(data, length);
     148    }
     149
     150    template<typename T, typename Converter> void addCharacters(const T* data)
    143151    {
    144152        if (m_hasPendingCharacter && *data) {
    145153            m_hasPendingCharacter = false;
    146             addCharactersAssumingAligned(m_pendingCharacter, Converter(*data++));
     154            addCharactersAssumingAligned(m_pendingCharacter, Converter::convert(*data++));
    147155        }
    148156        addCharactersAssumingAligned<T, Converter>(data);
    … …  
    151159    template<typename T> void addCharacters(const T* data)
    152160    {
    153         addCharacters<T, defaultConverter>(data);
     161        addCharacters<T, DefaultConverter>(data);
    154162    }
    155163
    … …  
    164172    }
    165173
    166     template<typename T, UChar Converter(T)> static constexpr unsigned computeHashAndMaskTop8Bits(const T* data, unsigned length)
     174    template<typename T, typename Converter> static constexpr unsigned computeHashAndMaskTop8Bits(const T* data, unsigned length)
    167175    {
    168176        return finalizeAndMaskTop8Bits(computeHashImpl<T, Converter>(data, length));
    169177    }
    170178
    171     template<typename T, UChar Converter(T)> static constexpr unsigned computeHashAndMaskTop8Bits(const T* data)
     179    template<typename T, typename Converter> static constexpr unsigned computeHashAndMaskTop8Bits(const T* data)
    172180    {
    173181        return finalizeAndMaskTop8Bits(computeHashImpl<T, Converter>(data));
    … …  
    176184    template<typename T> static constexpr unsigned computeHashAndMaskTop8Bits(const T* data, unsigned length)
    177185    {
    178         return computeHashAndMaskTop8Bits<T, defaultConverter>(data, length);
     186        return computeHashAndMaskTop8Bits<T, DefaultConverter>(data, length);
    179187    }
    180188
    181189    template<typename T> static constexpr unsigned computeHashAndMaskTop8Bits(const T* data)
    182190    {
    183         return computeHashAndMaskTop8Bits<T, defaultConverter>(data);
    184     }
    185 
    186     template<typename T, UChar Converter(T)> static constexpr unsigned computeHash(const T* data, unsigned length)
     191        return computeHashAndMaskTop8Bits<T, DefaultConverter>(data);
     192    }
     193
     194    template<typename T, typename Converter> static constexpr unsigned computeHash(const T* data, unsigned length)
    187195    {
    188196        return finalize(computeHashImpl<T, Converter>(data, length));
    189197    }
    190198
    191     template<typename T, UChar Converter(T)> static constexpr unsigned computeHash(const T* data)
     199    template<typename T, typename Converter> static constexpr unsigned computeHash(const T* data)
    192200    {
    193201        return finalize(computeHashImpl<T, Converter>(data));
    … …  
    196204    template<typename T> static constexpr unsigned computeHash(const T* data, unsigned length)
    197205    {
    198         return computeHash<T, defaultConverter>(data, length);
     206        return computeHash<T, DefaultConverter>(data, length);
    199207    }
    200208
    201209    template<typename T> static constexpr unsigned computeHash(const T* data)
    202210    {
    203         return computeHash<T, defaultConverter>(data);
     211        return computeHash<T, DefaultConverter>(data);
    204212    }
    205213
    … …  
    208216    static constexpr unsigned computeLiteralHash(const T (&characters)[charactersCount])
    209217    {
    210         return computeHash<T, defaultConverter>(characters, charactersCount - 1);
     218        return computeHash<T, DefaultConverter>(characters, charactersCount - 1);
    211219    }
    212220
    … …  
    214222    static constexpr unsigned computeLiteralHashAndMaskTop8Bits(const T (&characters)[charactersCount])
    215223    {
    216         return computeHashAndMaskTop8Bits<T, defaultConverter>(characters, charactersCount - 1);
     224        return computeHashAndMaskTop8Bits<T, DefaultConverter>(characters, charactersCount - 1);
    217225    }
    218226
    … …  
    235243
    236244private:
    237     static constexpr UChar defaultConverter(UChar character)
    238     {
    239         return character;
    240     }
    241 
    242     static constexpr UChar defaultConverter(LChar character)
    243     {
    244         return character;
    245     }
    246 
    247     static constexpr UChar defaultConverter(char character)
    248     {
    249         return static_cast<LChar>(character);
    250     }
    251 
    252     static constexpr UChar defaultConverter(char16_t character)
    253     {
    254         return character;
    255     }
    256 
    257245    ALWAYS_INLINE static constexpr unsigned avalancheBits(unsigned hash)
    258246    {
    … …  
    313301    }
    314302
    315     template<typename T, UChar Converter(T)>
     303    template<typename T, typename Converter>
    316304    static constexpr unsigned computeHashImpl(const T* characters, unsigned length)
    317305    {
    … …  
    321309
    322310        while (length--) {
    323             result = calculateWithTwoCharacters(result, Converter(characters[0]), Converter(characters[1]));
     311            result = calculateWithTwoCharacters(result, Converter::convert(characters[0]), Converter::convert(characters[1]));
    324312            characters += 2;
    325313        }
    326314
    327315        if (remainder)
    328             return calculateWithRemainingLastCharacter(result, Converter(characters[0]));
    329         return result;
    330     }
    331 
    332     template<typename T, UChar Converter(T)>
     316            return calculateWithRemainingLastCharacter(result, Converter::convert(characters[0]));
     317        return result;
     318    }
     319
     320    template<typename T, typename Converter>
    333321    static constexpr unsigned computeHashImpl(const T* characters)
    334322    {
    … …  
    337325            T b = *characters++;
    338326            if (!b)
    339                 return calculateWithRemainingLastCharacter(result, Converter(a));
    340             result = calculateWithTwoCharacters(result, Converter(a), Converter(b));
     327                return calculateWithRemainingLastCharacter(result, Converter::convert(a));
     328            result = calculateWithTwoCharacters(result, Converter::convert(a), Converter::convert(b));
    341329        }
    342330        return result;

  • trunk/Source/WebKit/ChangeLog

    r225747 r225751  
     12017-12-11  Yusuke Suzuki  <utatane.tea@gmail.com>
     2
     3        [WTF] Add Converter traits to StringHasher instead of function pointer
     4        https://bugs.webkit.org/show_bug.cgi?id=180656
     5
     6        Reviewed by JF Bastien.
     7
     8        * WebProcess/WebProcess.cpp:
     9        (WebKit::addCaseFoldedCharacters):
     10
    1112017-12-11  David Quesada  <david_quesada@apple.com>
    212

  • trunk/Source/WebKit/WebProcess/WebProcess.cpp

    r225597 r225751  
    780780        return;
    781781    if (string.is8Bit()) {
    782         hasher.addCharacters<LChar, ASCIICaseInsensitiveHash::foldCase<LChar>>(string.characters8(), string.length());
    783         return;
    784     }
    785     hasher.addCharacters<UChar, ASCIICaseInsensitiveHash::foldCase<UChar>>(string.characters16(), string.length());
     782        hasher.addCharacters<LChar, ASCIICaseInsensitiveHash::FoldCase<LChar>>(string.characters8(), string.length());
     783        return;
     784    }
     785    hasher.addCharacters<UChar, ASCIICaseInsensitiveHash::FoldCase<UChar>>(string.characters16(), string.length());
    786786}
    787787
Note: See TracChangeset for help on using the changeset viewer.