/*
- * 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 <type_traits>
#include <stdexcept>
#include <typeinfo>
-#include "double-conversion.h" // V8 JavaScript implementation
+#include <limits.h>
+
+// V8 JavaScript implementation
+#include <double-conversion/double-conversion.h>
#define FOLLY_RANGE_CHECK(condition, message) \
((condition) ? (void)0 : throw std::range_error( \
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 unsigned int
+unsafeTelescope128(char * buffer, unsigned int room, unsigned __int128 x) {
+ typedef unsigned __int128 Usrc;
+ unsigned int 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];
+ unsigned int 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>()];
+ unsigned int 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);
}
-#if defined(__GNUC__) && __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)
+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
/**
*/
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
/**
*/
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) {
/* 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
/*******************************************************************************
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,
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.
+ * Very primitive, lets say its our best effort
*/
+template <class Src>
+typename std::enable_if<
+ std::is_floating_point<Src>::value, size_t>::type
+estimateSpaceNeeded(Src value) {
+ size_t sofar = 0;
+ if (value < 0) {
+ ++sofar;
+ value = -value;
+ }
+
+ if (value < 1) {
+ return sofar + 10; // lets assume 0 + '.' + 8 precision digits
+ }
+
+ if (value < static_cast<double>(std::numeric_limits<uint64_t>::max())) {
+ sofar += digits10(static_cast<uint64_t>(value));
+ } else {
+ return 64; // give up, it will be more than 23 anyway
+ }
+
+ return sofar + 10; // integral part + '.' + 8 precision digits
+}
+
+/**
+ * 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(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 will reserve
+ * the space for them (at least we will try).
+ */
+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::reserveInTarget(vs...);
+ detail::toAppendStrImpl(vs...);
}
/**
* 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.
+ */
+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::reserveInTargetDelim(delim, vs...);
+ detail::toAppendDelimStrImpl(delim, vs...);
+}
+
+/**
+ * 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);
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;
+ toAppendDelim(delim, vs..., &result);
+ return result;
+}
+
/*******************************************************************************
* Conversions from string types to integral types.
******************************************************************************/
// 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());
* Enum to anything and back
******************************************************************************/
-#if defined(__GNUC__) && __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)
+#if defined(__clang__) || __GNUC_PREREQ(4, 7)
// std::underlying_type became available by gcc 4.7.0
template <class Tgt, class Src>
projects / folly.git / blobdiff