/*
- * Copyright 2012 Facebook, Inc.
+ * Copyright 2014 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#ifndef FOLLY_BASE_CONV_H_
#define FOLLY_BASE_CONV_H_
-#include "folly/FBString.h"
-#include "folly/Likely.h"
-#include "folly/Preprocessor.h"
-#include "folly/Range.h"
+#include <folly/FBString.h>
+#include <folly/Likely.h>
+#include <folly/Preprocessor.h>
+#include <folly/Range.h>
#include <boost/implicit_cast.hpp>
+#include <algorithm>
#include <type_traits>
#include <limits>
#include <string>
#include <stdexcept>
#include <typeinfo>
-#include "double-conversion.h" // V8 JavaScript implementation
+#include <limits.h>
-#define FOLLY_RANGE_CHECK(condition, message) \
- ((condition) ? (void)0 : throw std::range_error( \
- (__FILE__ "(" + std::to_string((long long int) __LINE__) + "): " \
+// V8 JavaScript implementation
+#include <double-conversion/double-conversion.h>
+
+#define FOLLY_RANGE_CHECK_STRINGIZE(x) #x
+#define FOLLY_RANGE_CHECK_STRINGIZE2(x) FOLLY_RANGE_CHECK_STRINGIZE(x)
+
+#define FOLLY_RANGE_CHECK(condition, message) \
+ ((condition) ? (void)0 : throw std::range_error( \
+ (std::string(__FILE__ "(" FOLLY_RANGE_CHECK_STRINGIZE2(__LINE__) "): ") \
+ (message)).c_str()))
namespace folly {
to(const Src & value) {
/* static */ if (std::numeric_limits<Tgt>::max()
< std::numeric_limits<Src>::max()) {
- FOLLY_RANGE_CHECK(value <= std::numeric_limits<Tgt>::max(),
- "Overflow");
+ FOLLY_RANGE_CHECK(
+ (!greater_than<Tgt, std::numeric_limits<Tgt>::max()>(value)),
+ "Overflow"
+ );
}
/* static */ if (std::is_signed<Src>::value &&
(!std::is_signed<Tgt>::value || sizeof(Src) > sizeof(Tgt))) {
- FOLLY_RANGE_CHECK(value >= std::numeric_limits<Tgt>::min(),
- "Negative overflow");
+ FOLLY_RANGE_CHECK(
+ (!less_than<Tgt, std::numeric_limits<Tgt>::min()>(value)),
+ "Negative overflow"
+ );
}
return static_cast<Tgt>(value);
}
namespace detail {
-template <class T> struct IsSomeString {
- enum { value = std::is_same<T, std::string>::value
- || std::is_same<T, fbstring>::value };
-};
-
template <class T>
const T& getLastElement(const T & v) {
return v;
return getLastElement(vs...);
}
+// This class exists to specialize away std::tuple_element in the case where we
+// have 0 template arguments. Without this, Clang/libc++ will blow a
+// static_assert even if tuple_element is protected by an enable_if.
+template <class... Ts>
+struct last_element {
+ typedef typename std::enable_if<
+ sizeof...(Ts) >= 1,
+ typename std::tuple_element<
+ sizeof...(Ts) - 1, std::tuple<Ts...>
+ >::type>::type type;
+};
+
+template <>
+struct last_element<> {
+ typedef void type;
+};
+
} // namespace detail
/*******************************************************************************
* Conversions from integral types to string types.
******************************************************************************/
+#if FOLLY_HAVE_INT128_T
+namespace detail {
+
+template <typename IntegerType>
+constexpr unsigned int
+digitsEnough() {
+ return ceil((double(sizeof(IntegerType) * CHAR_BIT) * M_LN2) / M_LN10);
+}
+
+inline size_t
+unsafeTelescope128(char * buffer, size_t room, unsigned __int128 x) {
+ typedef unsigned __int128 Usrc;
+ size_t p = room - 1;
+
+ while (x >= (Usrc(1) << 64)) { // Using 128-bit division while needed
+ const auto y = x / 10;
+ const auto digit = x % 10;
+
+ buffer[p--] = '0' + digit;
+ x = y;
+ }
+
+ uint64_t xx = x; // Moving to faster 64-bit division thereafter
+
+ while (xx >= 10) {
+ const auto y = xx / 10ULL;
+ const auto digit = xx % 10ULL;
+
+ buffer[p--] = '0' + digit;
+ xx = y;
+ }
+
+ buffer[p] = '0' + xx;
+
+ return p;
+}
+
+}
+#endif
+
/**
* Returns the number of digits in the base 10 representation of an
* uint64_t. Useful for preallocating buffers and such. It's also used
*result += value;
}
+template<class T>
+constexpr typename std::enable_if<
+ std::is_same<T, char>::value,
+ size_t>::type
+estimateSpaceNeeded(T) {
+ return 1;
+}
+
+/**
+ * Ubiquitous helper template for writing string appenders
+ */
+template <class T> struct IsSomeString {
+ enum { value = std::is_same<T, std::string>::value
+ || std::is_same<T, fbstring>::value };
+};
+
/**
* Everything implicitly convertible to const char* gets appended.
*/
template <class Tgt, class Src>
typename std::enable_if<
std::is_convertible<Src, const char*>::value
- && detail::IsSomeString<Tgt>::value>::type
+ && IsSomeString<Tgt>::value>::type
toAppend(Src value, Tgt * result) {
// Treat null pointers like an empty string, as in:
// operator<<(std::ostream&, const char*).
}
}
+template<class Src>
+typename std::enable_if<
+ std::is_convertible<Src, const char*>::value,
+ size_t>::type
+estimateSpaceNeeded(Src value) {
+ const char *c = value;
+ if (c) {
+ return folly::StringPiece(value).size();
+ };
+ return 0;
+}
+
+template<class Src>
+typename std::enable_if<
+ (std::is_convertible<Src, folly::StringPiece>::value ||
+ IsSomeString<Src>::value) &&
+ !std::is_convertible<Src, const char*>::value,
+ size_t>::type
+estimateSpaceNeeded(Src value) {
+ return folly::StringPiece(value).size();
+}
+
+template<class Src>
+typename std::enable_if<
+ std::is_pointer<Src>::value &&
+ IsSomeString<std::remove_pointer<Src>>::value,
+ size_t>::type
+estimateSpaceNeeded(Src value) {
+ return value->size();
+}
+
/**
* Strings get appended, too.
*/
template <class Tgt, class Src>
typename std::enable_if<
- detail::IsSomeString<Src>::value && detail::IsSomeString<Tgt>::value>::type
+ IsSomeString<Src>::value && IsSomeString<Tgt>::value>::type
toAppend(const Src& value, Tgt * result) {
result->append(value);
}
*/
template <class Tgt>
typename std::enable_if<
- detail::IsSomeString<Tgt>::value>::type
+ IsSomeString<Tgt>::value>::type
toAppend(StringPiece value, Tgt * result) {
result->append(value.data(), value.size());
}
*/
template <class Tgt>
typename std::enable_if<
- detail::IsSomeString<Tgt>::value>::type
+ IsSomeString<Tgt>::value>::type
toAppend(const fbstring& value, Tgt * result) {
result->append(value.data(), value.size());
}
+#if FOLLY_HAVE_INT128_T
+/**
+ * Special handling for 128 bit integers.
+ */
+
+template <class Tgt>
+void
+toAppend(__int128 value, Tgt * result) {
+ typedef unsigned __int128 Usrc;
+ char buffer[detail::digitsEnough<unsigned __int128>() + 1];
+ size_t p;
+
+ if (value < 0) {
+ p = detail::unsafeTelescope128(buffer, sizeof(buffer), Usrc(-value));
+ buffer[--p] = '-';
+ } else {
+ p = detail::unsafeTelescope128(buffer, sizeof(buffer), value);
+ }
+
+ result->append(buffer + p, buffer + sizeof(buffer));
+}
+
+template <class Tgt>
+void
+toAppend(unsigned __int128 value, Tgt * result) {
+ char buffer[detail::digitsEnough<unsigned __int128>()];
+ size_t p;
+
+ p = detail::unsafeTelescope128(buffer, sizeof(buffer), value);
+
+ result->append(buffer + p, buffer + sizeof(buffer));
+}
+
+template<class T>
+constexpr typename std::enable_if<
+ std::is_same<T, __int128>::value,
+ size_t>::type
+estimateSpaceNeeded(T) {
+ return detail::digitsEnough<__int128>();
+}
+
+template<class T>
+constexpr typename std::enable_if<
+ std::is_same<T, unsigned __int128>::value,
+ size_t>::type
+estimateSpaceNeeded(T) {
+ return detail::digitsEnough<unsigned __int128>();
+}
+
+#endif
+
/**
* int32_t and int64_t to string (by appending) go through here. The
* result is APPENDED to a preexisting string passed as the second
- * parameter. For convenience, the function also returns a reference
- * to *result. This should be efficient with fbstring because fbstring
+ * parameter. This should be efficient with fbstring because fbstring
* incurs no dynamic allocation below 23 bytes and no number has more
* than 22 bytes in its textual representation (20 for digits, one for
* sign, one for the terminating 0).
*/
template <class Tgt, class Src>
typename std::enable_if<
- std::is_integral<Src>::value && std::is_signed<Src>::value
- && detail::IsSomeString<Tgt>::value && sizeof(Src) >= 4>::type
+ std::is_integral<Src>::value && std::is_signed<Src>::value &&
+ IsSomeString<Tgt>::value && sizeof(Src) >= 4>::type
toAppend(Src value, Tgt * result) {
- typedef typename std::make_unsigned<Src>::type Usrc;
char buffer[20];
if (value < 0) {
result->push_back('-');
}
}
+template <class Src>
+typename std::enable_if<
+ std::is_integral<Src>::value && std::is_signed<Src>::value
+ && sizeof(Src) >= 4 && sizeof(Src) < 16,
+ size_t>::type
+estimateSpaceNeeded(Src value) {
+ if (value < 0) {
+ return 1 + digits10(static_cast<uint64_t>(-value));
+ }
+
+ return digits10(static_cast<uint64_t>(value));
+}
+
/**
* As above, but for uint32_t and uint64_t.
*/
template <class Tgt, class Src>
typename std::enable_if<
std::is_integral<Src>::value && !std::is_signed<Src>::value
- && detail::IsSomeString<Tgt>::value && sizeof(Src) >= 4>::type
+ && IsSomeString<Tgt>::value && sizeof(Src) >= 4>::type
toAppend(Src value, Tgt * result) {
char buffer[20];
result->append(buffer, buffer + uint64ToBufferUnsafe(value, buffer));
}
+template <class Src>
+typename std::enable_if<
+ std::is_integral<Src>::value && !std::is_signed<Src>::value
+ && sizeof(Src) >= 4 && sizeof(Src) < 16,
+ size_t>::type
+estimateSpaceNeeded(Src value) {
+ return digits10(value);
+}
+
/**
* All small signed and unsigned integers to string go through 32-bit
* types int32_t and uint32_t, respectively.
template <class Tgt, class Src>
typename std::enable_if<
std::is_integral<Src>::value
- && detail::IsSomeString<Tgt>::value && sizeof(Src) < 4>::type
+ && IsSomeString<Tgt>::value && sizeof(Src) < 4>::type
toAppend(Src value, Tgt * result) {
typedef typename
std::conditional<std::is_signed<Src>::value, int64_t, uint64_t>::type
toAppend<Tgt>(static_cast<Intermediate>(value), result);
}
+template <class Src>
+typename std::enable_if<
+ std::is_integral<Src>::value
+ && sizeof(Src) < 4
+ && !std::is_same<Src, char>::value,
+ size_t>::type
+estimateSpaceNeeded(Src value) {
+ typedef typename
+ std::conditional<std::is_signed<Src>::value, int64_t, uint64_t>::type
+ Intermediate;
+ 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.
*/
template <class Tgt, class Src>
typename std::enable_if<
- std::is_enum<Src>::value && detail::IsSomeString<Tgt>::value>::type
+ std::is_enum<Src>::value && IsSomeString<Tgt>::value>::type
+toAppend(Src value, Tgt * result) {
+ toAppend(
+ static_cast<typename std::underlying_type<Src>::type>(value), result);
+}
+
+template <class Src>
+typename std::enable_if<
+ std::is_enum<Src>::value, size_t>::type
+estimateSpaceNeeded(Src value) {
+ return estimateSpaceNeeded(
+ 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)) {
}
}
+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.
******************************************************************************/
+namespace detail {
+constexpr int kConvMaxDecimalInShortestLow = -6;
+constexpr int kConvMaxDecimalInShortestHigh = 21;
+} // folly::detail
+
/** Wrapper around DoubleToStringConverter **/
template <class Tgt, class Src>
typename std::enable_if<
std::is_floating_point<Src>::value
- && detail::IsSomeString<Tgt>::value>::type
+ && IsSomeString<Tgt>::value>::type
toAppend(
Src value,
Tgt * result,
DoubleToStringConverter
conv(DoubleToStringConverter::NO_FLAGS,
"infinity", "NaN", 'E',
- -6, // decimal in shortest low
- 21, // decimal in shortest high
+ detail::kConvMaxDecimalInShortestLow,
+ detail::kConvMaxDecimalInShortestHigh,
6, // max leading padding zeros
1); // max trailing padding zeros
char buffer[256];
template <class Tgt, class Src>
typename std::enable_if<
std::is_floating_point<Src>::value
- && detail::IsSomeString<Tgt>::value>::type
+ && IsSomeString<Tgt>::value>::type
toAppend(Src value, Tgt * result) {
toAppend(
value, result, double_conversion::DoubleToStringConverter::SHORTEST, 0);
}
/**
- * Variadic conversion to string. Appends each element in turn.
+ * Upper bound of the length of the output from
+ * DoubleToStringConverter::ToShortest(double, StringBuilder*),
+ * as used in toAppend(double, string*).
+ */
+template <class Src>
+typename std::enable_if<
+ std::is_floating_point<Src>::value, size_t>::type
+estimateSpaceNeeded(Src value) {
+ // kBase10MaximalLength is 17. We add 1 for decimal point,
+ // e.g. 10.0/9 is 17 digits and 18 characters, including the decimal point.
+ constexpr int kMaxMantissaSpace =
+ double_conversion::DoubleToStringConverter::kBase10MaximalLength + 1;
+ // strlen("E-") + digits10(numeric_limits<double>::max_exponent10)
+ constexpr int kMaxExponentSpace = 2 + 3;
+ static const int kMaxPositiveSpace = std::max({
+ // E.g. 1.1111111111111111E-100.
+ kMaxMantissaSpace + kMaxExponentSpace,
+ // E.g. 0.000001.1111111111111111, if kConvMaxDecimalInShortestLow is -6.
+ kMaxMantissaSpace - detail::kConvMaxDecimalInShortestLow,
+ // If kConvMaxDecimalInShortestHigh is 21, then 1e21 is the smallest
+ // number > 1 which ToShortest outputs in exponential notation,
+ // so 21 is the longest non-exponential number > 1.
+ detail::kConvMaxDecimalInShortestHigh
+ });
+ return kMaxPositiveSpace + (value < 0); // +1 for minus sign, if negative
+}
+
+/**
+ * This can be specialized, together with adding specialization
+ * for estimateSpaceNeed for your type, so that we allocate
+ * as much as you need instead of the default
+ */
+template<class Src>
+struct HasLengthEstimator : std::false_type {};
+
+template <class Src>
+constexpr typename std::enable_if<
+ !std::is_fundamental<Src>::value
+ && !IsSomeString<Src>::value
+ && !std::is_convertible<Src, const char*>::value
+ && !std::is_convertible<Src, StringPiece>::value
+ && !std::is_enum<Src>::value
+ && !HasLengthEstimator<Src>::value,
+ size_t>::type
+estimateSpaceNeeded(const Src&) {
+ return sizeof(Src) + 1; // dumbest best effort ever?
+}
+
+namespace detail {
+
+inline size_t estimateSpaceToReserve(size_t sofar) {
+ return sofar;
+}
+
+template <class T, class... Ts>
+size_t estimateSpaceToReserve(size_t sofar, const T& v, const Ts&... vs) {
+ return estimateSpaceToReserve(sofar + estimateSpaceNeeded(v), vs...);
+}
+
+template<class T>
+size_t estimateSpaceToReserve(size_t sofar, const T& v) {
+ return sofar + estimateSpaceNeeded(v);
+}
+
+template<class...Ts>
+void reserveInTarget(const Ts&...vs) {
+ getLastElement(vs...)->reserve(estimateSpaceToReserve(0, vs...));
+}
+
+template<class Delimiter, class...Ts>
+void reserveInTargetDelim(const Delimiter& d, const Ts&...vs) {
+ static_assert(sizeof...(vs) >= 2, "Needs at least 2 args");
+ size_t fordelim = (sizeof...(vs) - 2) * estimateSpaceToReserve(0, d);
+ getLastElement(vs...)->reserve(estimateSpaceToReserve(fordelim, vs...));
+}
+
+/**
+ * Variadic base case: append one element
*/
+template <class T, class Tgt>
+typename std::enable_if<
+ IsSomeString<typename std::remove_pointer<Tgt>::type>
+ ::value>::type
+toAppendStrImpl(const T& v, Tgt result) {
+ toAppend(v, result);
+}
+
template <class T, class... Ts>
typename std::enable_if<sizeof...(Ts) >= 2
- && detail::IsSomeString<
+ && IsSomeString<
typename std::remove_pointer<
- typename std::tuple_element<
- sizeof...(Ts) - 1, std::tuple<Ts...>
- >::type>::type>::value>::type
-toAppend(const T& v, const Ts&... vs) {
+ typename detail::last_element<Ts...>::type
+ >::type>::value>::type
+toAppendStrImpl(const T& v, const Ts&... vs) {
+ toAppend(v, getLastElement(vs...));
+ toAppendStrImpl(vs...);
+}
+
+template <class Delimiter, class T, class Tgt>
+typename std::enable_if<
+ IsSomeString<typename std::remove_pointer<Tgt>::type>
+ ::value>::type
+toAppendDelimStrImpl(const Delimiter& delim, const T& v, Tgt result) {
+ toAppend(v, result);
+}
+
+template <class Delimiter, class T, class... Ts>
+typename std::enable_if<sizeof...(Ts) >= 2
+ && IsSomeString<
+ typename std::remove_pointer<
+ typename detail::last_element<Ts...>::type
+ >::type>::value>::type
+toAppendDelimStrImpl(const Delimiter& delim, const T& v, const Ts&... vs) {
+ // we are really careful here, calling toAppend with just one element does
+ // not try to estimate space needed (as we already did that). If we call
+ // toAppend(v, delim, ....) we would do unnecesary size calculation
toAppend(v, detail::getLastElement(vs...));
+ toAppend(delim, detail::getLastElement(vs...));
+ toAppendDelimStrImpl(delim, vs...);
+}
+} // folly::detail
+
+
+/**
+ * Variadic conversion to string. Appends each element in turn.
+ * If we have two or more things to append, we it will not reserve
+ * the space for them and will depend on strings exponential growth.
+ * If you just append once consider using toAppendFit which reserves
+ * the space needed (but does not have exponential as a result).
+ */
+template <class... Ts>
+typename std::enable_if<sizeof...(Ts) >= 3
+ && IsSomeString<
+ typename std::remove_pointer<
+ typename detail::last_element<Ts...>::type
+ >::type>::value>::type
+toAppend(const Ts&... vs) {
+ detail::toAppendStrImpl(vs...);
+}
+
+/**
+ * Special version of the call that preallocates exaclty as much memory
+ * as need for arguments to be stored in target. This means we are
+ * not doing exponential growth when we append. If you are using it
+ * in a loop you are aiming at your foot with a big perf-destroying
+ * bazooka.
+ * On the other hand if you are appending to a string once, this
+ * will probably save a few calls to malloc.
+ */
+template <class... Ts>
+typename std::enable_if<
+ IsSomeString<
+ typename std::remove_pointer<
+ typename detail::last_element<Ts...>::type
+ >::type>::value>::type
+toAppendFit(const Ts&... vs) {
+ detail::reserveInTarget(vs...);
toAppend(vs...);
}
+template <class Ts>
+void toAppendFit(const Ts&) {}
+
/**
* Variadic base case: do nothing.
*/
template <class Tgt>
-typename std::enable_if<detail::IsSomeString<Tgt>::value>::type
+typename std::enable_if<IsSomeString<Tgt>::value>::type
toAppend(Tgt* result) {
}
+/**
+ * Variadic base case: do nothing.
+ */
+template <class Delimiter, class Tgt>
+typename std::enable_if<IsSomeString<Tgt>::value>::type
+toAppendDelim(const Delimiter& delim, Tgt* result) {
+}
+
+/**
+ * 1 element: same as toAppend.
+ */
+template <class Delimiter, class T, class Tgt>
+typename std::enable_if<IsSomeString<Tgt>::value>::type
+toAppendDelim(const Delimiter& delim, const T& v, Tgt* tgt) {
+ toAppend(v, tgt);
+}
+
+/**
+ * Append to string with a delimiter in between elements. Check out
+ * comments for toAppend for details about memory allocation.
+ */
+template <class Delimiter, class... Ts>
+typename std::enable_if<sizeof...(Ts) >= 3
+ && IsSomeString<
+ typename std::remove_pointer<
+ typename detail::last_element<Ts...>::type
+ >::type>::value>::type
+toAppendDelim(const Delimiter& delim, const Ts&... vs) {
+ detail::toAppendDelimStrImpl(delim, vs...);
+}
+
+/**
+ * Detail in comment for toAppendFit
+ */
+template <class Delimiter, class... Ts>
+typename std::enable_if<
+ IsSomeString<
+ typename std::remove_pointer<
+ typename detail::last_element<Ts...>::type
+ >::type>::value>::type
+toAppendDelimFit(const Delimiter& delim, const Ts&... vs) {
+ detail::reserveInTargetDelim(delim, vs...);
+ toAppendDelim(delim, vs...);
+}
+
+template <class De, class Ts>
+void toAppendDelimFit(const De&, const Ts&) {}
+
+/**
+ * to<SomeString>(SomeString str) returns itself. As both std::string and
+ * folly::fbstring use Copy-on-Write, it's much more efficient by
+ * avoiding copying the underlying char array.
+ */
+template <class Tgt, class Src>
+typename std::enable_if<
+ IsSomeString<Tgt>::value && std::is_same<Tgt, Src>::value,
+ Tgt>::type
+to(const Src & value) {
+ return value;
+}
+
/**
* to<SomeString>(v1, v2, ...) uses toAppend() (see below) as back-end
* for all types.
*/
template <class Tgt, class... Ts>
-typename std::enable_if<detail::IsSomeString<Tgt>::value, Tgt>::type
+typename std::enable_if<
+ IsSomeString<Tgt>::value && (
+ sizeof...(Ts) != 1 ||
+ !std::is_same<Tgt, typename detail::last_element<Ts...>::type>::value),
+ Tgt>::type
to(const Ts&... vs) {
Tgt result;
- toAppend(vs..., &result);
+ toAppendFit(vs..., &result);
+ return result;
+}
+
+/**
+ * toDelim<SomeString>(SomeString str) returns itself.
+ */
+template <class Tgt, class Delim, class Src>
+typename std::enable_if<
+ IsSomeString<Tgt>::value && std::is_same<Tgt, Src>::value,
+ Tgt>::type
+toDelim(const Delim& delim, const Src & value) {
+ return value;
+}
+
+/**
+ * toDelim<SomeString>(delim, v1, v2, ...) uses toAppendDelim() as
+ * back-end for all types.
+ */
+template <class Tgt, class Delim, class... Ts>
+typename std::enable_if<
+ IsSomeString<Tgt>::value && (
+ sizeof...(Ts) != 1 ||
+ !std::is_same<Tgt, typename detail::last_element<Ts...>::type>::value),
+ Tgt>::type
+toDelim(const Delim& delim, const Ts&... vs) {
+ Tgt result;
+ toAppendDelimFit(delim, vs..., &result);
return result;
}
// still not overflow uint16_t.
constexpr int32_t OOR = 10000;
-__attribute__((aligned(16))) constexpr uint16_t shift1[] = {
+__attribute__((__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[] = {
+__attribute__((__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[] = {
+__attribute__((__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[] = {
+__attribute__((__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
auto t = detail::digits_to<typename std::make_unsigned<Tgt>::type>(b, m);
if (negative) {
result = -t;
- FOLLY_RANGE_CHECK(result <= 0, "Negative overflow");
+ FOLLY_RANGE_CHECK(is_non_positive(result), "Negative overflow");
} else {
result = t;
- FOLLY_RANGE_CHECK(result >= 0, "Overflow");
+ FOLLY_RANGE_CHECK(is_non_negative(result), "Overflow");
}
}
src->advance(m - src->data());
FOLLY_RANGE_CHECK(!src->empty(), "No digits found in input string");
int length;
- auto result = conv.StringToDouble(src->data(), src->size(),
- &length); // processed char count
+ auto result = conv.StringToDouble(src->data(),
+ static_cast<int>(src->size()),
+ &length); // processed char count
if (!std::isnan(result)) {
src->advance(length);
* 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, Tgt>::type
+to(const Src & value) {
+ return to<Tgt>(static_cast<typename std::underlying_type<Src>::type>(value));
+}
+
+template <class Tgt, class Src>
+typename std::enable_if<std::is_enum<Tgt>::value, Tgt>::type
+to(const Src & value) {
+ 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, Tgt>::type
to(const Src & value) {
- // TODO: uncomment this when underlying_type is available
- // return to<Tgt>(static_cast<typename std::underlying_type<Src>::type>(
- // value));
/* static */ if (Src(-1) < 0) {
/* static */ if (sizeof(Src) <= sizeof(int)) {
return to<Tgt>(static_cast<int>(value));
template <class Tgt, class Src>
typename std::enable_if<std::is_enum<Tgt>::value, Tgt>::type
to(const Src & value) {
- // TODO: uncomment this when underlying_type is available
- // return static_cast<Tgt>(
- // to<typename std::underlying_type<Tgt>::type>(value));
/* static */ if (Tgt(-1) < 0) {
/* static */ if (sizeof(Tgt) <= sizeof(int)) {
return static_cast<Tgt>(to<int>(value));
}
}
+#endif // gcc 4.7 onwards
+
} // namespace folly
// FOLLY_CONV_INTERNAL is defined by Conv.cpp. Keep the FOLLY_RANGE_CHECK
// to avoid defining this global macro name in other files that include Conv.h.
#ifndef FOLLY_CONV_INTERNAL
#undef FOLLY_RANGE_CHECK
+#undef FOLLY_RANGE_CHECK_STRINGIZE2
+#undef FOLLY_RANGE_CHECK_STRINGIZE
#endif
#endif /* FOLLY_BASE_CONV_H_ */
projects / folly.git / blobdiff