typename std::tuple_element<
sizeof...(Ts),
std::tuple<T, Ts...> >::type const&
- getLastElement(const T& v, const Ts&... vs) {
+ getLastElement(const T&, const Ts&... vs) {
return getLastElement(vs...);
}
*/
inline uint32_t digits10(uint64_t v) {
+#ifdef __x86_64__
+
+ // For this arch we can get a little help from specialized CPU instructions
+ // which can count leading zeroes; 64 minus that is appx. log (base 2).
+ // Use that to approximate base-10 digits (log_10) and then adjust if needed.
+
+ // 10^i, defined for i 0 through 19.
+ // This is 20 * 8 == 160 bytes, which fits neatly into 5 cache lines
+ // (assuming a cache line size of 64).
+ static const uint64_t powersOf10[20] FOLLY_ALIGNED(64) = {
+ 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000,
+ 10000000000, 100000000000, 1000000000000, 10000000000000, 100000000000000,
+ 1000000000000000, 10000000000000000, 100000000000000000,
+ 1000000000000000000, 10000000000000000000UL
+ };
+
+ // "count leading zeroes" operation not valid; for 0; special case this.
+ if UNLIKELY (! v) {
+ return 1;
+ }
+
+ // bits is in the ballpark of log_2(v).
+ const uint8_t leadingZeroes = __builtin_clzll(v);
+ const auto bits = 63 - leadingZeroes;
+
+ // approximate log_10(v) == log_10(2) * bits.
+ // Integer magic below: 77/256 is appx. 0.3010 (log_10(2)).
+ // The +1 is to make this the ceiling of the log_10 estimate.
+ const uint32_t minLength = 1 + ((bits * 77) >> 8);
+
+ // return that log_10 lower bound, plus adjust if input >= 10^(that bound)
+ // in case there's a small error and we misjudged length.
+ return minLength + (uint32_t) (UNLIKELY (v >= powersOf10[minLength]));
+
+#else
+
uint32_t result = 1;
for (;;) {
if (LIKELY(v < 10)) return result;
v /= 10000U;
result += 4;
}
+
+#endif
}
/**
return estimateSpaceNeeded(static_cast<Intermediate>(value));
}
-#if defined(__clang__) || __GNUC_PREREQ(4, 7)
-// std::underlying_type became available by gcc 4.7.0
-
/**
* Enumerated values get appended as integers.
*/
static_cast<typename std::underlying_type<Src>::type>(value));
}
-#else
-
-/**
- * Enumerated values get appended as integers.
- */
-template <class Tgt, class Src>
-typename std::enable_if<
- std::is_enum<Src>::value && IsSomeString<Tgt>::value>::type
-toAppend(Src value, Tgt * result) {
- /* static */ if (Src(-1) < 0) {
- /* static */ if (sizeof(Src) <= sizeof(int)) {
- toAppend(static_cast<int>(value), result);
- } else {
- toAppend(static_cast<long>(value), result);
- }
- } else {
- /* static */ if (sizeof(Src) <= sizeof(int)) {
- toAppend(static_cast<unsigned int>(value), result);
- } else {
- toAppend(static_cast<unsigned long>(value), result);
- }
- }
-}
-
-template <class Src>
-typename std::enable_if<
- std::is_enum<Src>::value, size_t>::type
-estimateSpaceNeeded(Src value) {
- /* static */ if (Src(-1) < 0) {
- /* static */ if (sizeof(Src) <= sizeof(int)) {
- return estimateSpaceNeeded(static_cast<int>(value));
- } else {
- return estimateSpaceNeeded(static_cast<long>(value));
- }
- } else {
- /* static */ if (sizeof(Src) <= sizeof(int)) {
- return estimateSpaceNeeded(static_cast<unsigned int>(value));
- } else {
- return estimateSpaceNeeded(static_cast<unsigned long>(value));
- }
- }
-}
-
-#endif // gcc 4.7 onwards
-
/*******************************************************************************
* Conversions from floating-point types to string types.
******************************************************************************/
using namespace double_conversion;
DoubleToStringConverter
conv(DoubleToStringConverter::NO_FLAGS,
- "infinity", "NaN", 'E',
+ "Infinity", "NaN", 'E',
detail::kConvMaxDecimalInShortestLow,
detail::kConvMaxDecimalInShortestHigh,
6, // max leading padding zeros
typename detail::last_element<Ts...>::type
>::type>::value>::type
toAppend(const Ts&... vs) {
- detail::toAppendStrImpl(vs...);
+ ::folly::detail::toAppendStrImpl(vs...);
}
/**
typename detail::last_element<Ts...>::type
>::type>::value>::type
toAppendFit(const Ts&... vs) {
- detail::reserveInTarget(vs...);
+ ::folly::detail::reserveInTarget(vs...);
toAppend(vs...);
}
// still not overflow uint16_t.
constexpr int32_t OOR = 10000;
-__attribute__((__aligned__(16))) constexpr uint16_t shift1[] = {
+FOLLY_ALIGNED(16) constexpr uint16_t shift1[] = {
OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 0-9
OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 10
OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 20
OOR, OOR, OOR, OOR, OOR, OOR // 250
};
-__attribute__((__aligned__(16))) constexpr uint16_t shift10[] = {
+FOLLY_ALIGNED(16) constexpr uint16_t shift10[] = {
OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 0-9
OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 10
OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 20
OOR, OOR, OOR, OOR, OOR, OOR // 250
};
-__attribute__((__aligned__(16))) constexpr uint16_t shift100[] = {
+FOLLY_ALIGNED(16) constexpr uint16_t shift100[] = {
OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 0-9
OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 10
OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 20
OOR, OOR, OOR, OOR, OOR, OOR // 250
};
-__attribute__((__aligned__(16))) constexpr uint16_t shift1000[] = {
+FOLLY_ALIGNED(16) constexpr uint16_t shift1000[] = {
OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 0-9
OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 10
OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 20
* Enum to anything and back
******************************************************************************/
-#if defined(__clang__) || __GNUC_PREREQ(4, 7)
-// std::underlying_type became available by gcc 4.7.0
-
template <class Tgt, class Src>
typename std::enable_if<
std::is_enum<Src>::value && !std::is_same<Src, Tgt>::value, Tgt>::type
return static_cast<Tgt>(to<typename std::underlying_type<Tgt>::type>(value));
}
-#else
-
-template <class Tgt, class Src>
-typename std::enable_if<
- std::is_enum<Src>::value && !std::is_same<Src, Tgt>::value, Tgt>::type
-to(const Src & value) {
- /* static */ if (Src(-1) < 0) {
- /* static */ if (sizeof(Src) <= sizeof(int)) {
- return to<Tgt>(static_cast<int>(value));
- } else {
- return to<Tgt>(static_cast<long>(value));
- }
- } else {
- /* static */ if (sizeof(Src) <= sizeof(int)) {
- return to<Tgt>(static_cast<unsigned int>(value));
- } else {
- return to<Tgt>(static_cast<unsigned long>(value));
- }
- }
-}
-
-template <class Tgt, class Src>
-typename std::enable_if<
- std::is_enum<Tgt>::value && !std::is_same<Src, Tgt>::value, Tgt>::type
-to(const Src & value) {
- /* static */ if (Tgt(-1) < 0) {
- /* static */ if (sizeof(Tgt) <= sizeof(int)) {
- return static_cast<Tgt>(to<int>(value));
- } else {
- return static_cast<Tgt>(to<long>(value));
- }
- } else {
- /* static */ if (sizeof(Tgt) <= sizeof(int)) {
- return static_cast<Tgt>(to<unsigned int>(value));
- } else {
- return static_cast<Tgt>(to<unsigned long>(value));
- }
- }
-}
-
-#endif // gcc 4.7 onwards
-
} // namespace folly
// FOLLY_CONV_INTERNAL is defined by Conv.cpp. Keep the FOLLY_RANGE_CHECK