1 /*

     2  * Copyright (C) 2009 Apple Inc. All Rights Reserved.

     3  *

     4  * Redistribution and use in source and binary forms, with or without

     5  * modification, are permitted provided that the following conditions

     6  * are met:

     7  * 1. Redistributions of source code must retain the above copyright

     8  *    notice, this list of conditions and the following disclaimer.

     9  * 2. Redistributions in binary form must reproduce the above copyright

    10  *    notice, this list of conditions and the following disclaimer in the

    11  *    documentation and/or other materials provided with the distribution.

    12  *

    13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY

    14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

    15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

    16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR

    17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

    18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

    19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

    20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

    21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

    22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

    23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

    24  */

    25 

    26 #ifndef NumericStrings_h

    27 #define NumericStrings_h

    28 

    29 #include "UString.h"

    30 #include <wtf/FixedArray.h>

    31 #include <wtf/HashFunctions.h>

    32 

    33 namespace JSC {

    34 

    35     class NumericStrings {

    36     public:

    37         UString add(double d)

    38         {

    39             CacheEntry<double>& entry = lookup(d);

    40             if (d == entry.key && !entry.value.isNull())

    41                 return entry.value;

    42             entry.key = d;

    43             entry.value = UString::from(d);

    44             return entry.value;

    45         }

    46 

    47         UString add(int i)

    48         {

    49             if (static_cast<unsigned>(i) < cacheSize)

    50                 return lookupSmallString(static_cast<unsigned>(i));

    51             CacheEntry<int>& entry = lookup(i);

    52             if (i == entry.key && !entry.value.isNull())

    53                 return entry.value;

    54             entry.key = i;

    55             entry.value = UString::from(i);

    56             return entry.value;

    57         }

    58 

    59         UString add(unsigned i)

    60         {

    61             if (i < cacheSize)

    62                 return lookupSmallString(static_cast<unsigned>(i));

    63             CacheEntry<unsigned>& entry = lookup(i);

    64             if (i == entry.key && !entry.value.isNull())

    65                 return entry.value;

    66             entry.key = i;

    67             entry.value = UString::from(i);

    68             return entry.value;

    69         }

    70     private:

    71         static const size_t cacheSize = 64;

    72 

    73         template<typename T>

    74         struct CacheEntry {

    75             T key;

    76             UString value;

    77         };

    78 

    79         CacheEntry<double>& lookup(double d) { return doubleCache[WTF::FloatHash<double>::hash(d) & (cacheSize - 1)]; }

    80         CacheEntry<int>& lookup(int i) { return intCache[WTF::IntHash<int>::hash(i) & (cacheSize - 1)]; }

    81         CacheEntry<unsigned>& lookup(unsigned i) { return unsignedCache[WTF::IntHash<unsigned>::hash(i) & (cacheSize - 1)]; }

    82         const UString& lookupSmallString(unsigned i)

    83         {

    84             ASSERT(i < cacheSize);

    85             if (smallIntCache[i].isNull())

    86                 smallIntCache[i] = UString::from(i);

    87             return smallIntCache[i];

    88         }

    89 

    90         FixedArray<CacheEntry<double>, cacheSize> doubleCache;

    91         FixedArray<CacheEntry<int>, cacheSize> intCache;

    92         FixedArray<CacheEntry<unsigned>, cacheSize> unsignedCache;

    93         FixedArray<UString, cacheSize> smallIntCache;

    94     };

    95 

    96 } // namespace JSC

    97 

    98 #endif // NumericStrings_h