/* * Copyright 2016 Facebook, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /** * Converts anything to anything, with an emphasis on performance and * safety. * * @author Andrei Alexandrescu (andrei.alexandrescu@fb.com) */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include // V8 JavaScript implementation #include #include #include #include #include #include #include #include namespace folly { // Keep this in sync with kErrorStrings in Conv.cpp enum class ConversionCode : unsigned char { SUCCESS, EMPTY_INPUT_STRING, NO_DIGITS, BOOL_OVERFLOW, BOOL_INVALID_VALUE, NON_DIGIT_CHAR, INVALID_LEADING_CHAR, POSITIVE_OVERFLOW, NEGATIVE_OVERFLOW, STRING_TO_FLOAT_ERROR, NON_WHITESPACE_AFTER_END, ARITH_POSITIVE_OVERFLOW, ARITH_NEGATIVE_OVERFLOW, ARITH_LOSS_OF_PRECISION, NUM_ERROR_CODES, // has to be the last entry }; struct ConversionErrorBase : std::range_error { using std::range_error::range_error; }; class ConversionError : public ConversionErrorBase { public: ConversionError(const std::string& str, ConversionCode code) : ConversionErrorBase(str), code_(code) {} ConversionError(const char* str, ConversionCode code) : ConversionErrorBase(str), code_(code) {} ConversionCode errorCode() const { return code_; } private: ConversionCode code_; }; /******************************************************************************* * Custom Error Translation * * Your overloaded parseTo() function can return a custom error code on failure. * ::folly::to() will call makeConversionError to translate that error code into * an object to throw. makeConversionError is found by argument-dependent * lookup. It should have this signature: * * namespace other_namespace { * enum YourErrorCode { BAD_ERROR, WORSE_ERROR }; * * struct YourConversionError : ConversionErrorBase { * YourConversionError(const char* what) : ConversionErrorBase(what) {} * }; * * YourConversionError * makeConversionError(YourErrorCode code, ::folly::StringPiece sp) { * ... * return YourConversionError(messageString); * } ******************************************************************************/ ConversionError makeConversionError(ConversionCode code, StringPiece sp); namespace detail { /** * Enforce that the suffix following a number is made up only of whitespace. */ inline ConversionCode enforceWhitespaceErr(StringPiece sp) { for (auto c : sp) { if (UNLIKELY(!std::isspace(c))) { return ConversionCode::NON_WHITESPACE_AFTER_END; } } return ConversionCode::SUCCESS; } /** * Keep this implementation around for prettyToDouble(). */ inline void enforceWhitespace(StringPiece sp) { auto err = enforceWhitespaceErr(sp); if (err != ConversionCode::SUCCESS) { throw makeConversionError(err, sp); } } } /** * The identity conversion function. * tryTo(T) returns itself for all types T. */ template typename std::enable_if< std::is_same::type>::value, Expected>::type tryTo(Src&& value) { return std::forward(value); } template typename std::enable_if< std::is_same::type>::value, Tgt>::type to(Src&& value) { return std::forward(value); } /******************************************************************************* * Arithmetic to boolean ******************************************************************************/ /** * Unchecked conversion from arithmetic to boolean. This is different from the * other arithmetic conversions because we use the C convention of treating any * non-zero value as true, instead of range checking. */ template typename std::enable_if< std::is_arithmetic::value && !std::is_same::value && std::is_same::value, Expected>::type tryTo(const Src& value) { return value != Src(); } template typename std::enable_if< std::is_arithmetic::value && !std::is_same::value && std::is_same::value, Tgt>::type to(const Src& value) { return value != Src(); } /******************************************************************************* * Anything to string ******************************************************************************/ namespace detail { #ifdef _MSC_VER // MSVC can't quite figure out the LastElementImpl::call() stuff // in the base implementation, so we have to use tuples instead, // which result in significantly more templates being compiled, // though the runtime performance is the same. template auto getLastElement(Ts&&... ts) -> decltype( std::get(std::forward_as_tuple(std::forward(ts)...))) { return std::get( std::forward_as_tuple(std::forward(ts)...)); } inline void getLastElement() {} template struct LastElementType : std::tuple_element> {}; template <> struct LastElementType<0> { using type = void; }; template struct LastElement : std::decay::type> {}; #else template struct LastElementImpl { static void call(Ignored...) {} }; template struct LastElementImpl { template static Last call(Ignored..., Last&& last) { return std::forward(last); } }; template auto getLastElement(const Ts&... ts) -> decltype(LastElementImpl::call(ts...)) { return LastElementImpl::call(ts...); } template struct LastElement : std::decay::call(std::declval()...))> { }; #endif } // namespace detail /******************************************************************************* * Conversions from integral types to string types. ******************************************************************************/ #if FOLLY_HAVE_INT128_T namespace detail { template constexpr unsigned int digitsEnough() { return (unsigned int)(ceil(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 * internally, see below. Measurements suggest that defining a * separate overload for 32-bit integers is not worthwhile. */ 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; if (LIKELY(v < 100)) return result + 1; if (LIKELY(v < 1000)) return result + 2; if (LIKELY(v < 10000)) return result + 3; // Skip ahead by 4 orders of magnitude v /= 10000U; result += 4; } #endif } /** * Copies the ASCII base 10 representation of v into buffer and * returns the number of bytes written. Does NOT append a \0. Assumes * the buffer points to digits10(v) bytes of valid memory. Note that * uint64 needs at most 20 bytes, uint32_t needs at most 10 bytes, * uint16_t needs at most 5 bytes, and so on. Measurements suggest * that defining a separate overload for 32-bit integers is not * worthwhile. * * This primitive is unsafe because it makes the size assumption and * because it does not add a terminating \0. */ inline uint32_t uint64ToBufferUnsafe(uint64_t v, char *const buffer) { auto const result = digits10(v); // WARNING: using size_t or pointer arithmetic for pos slows down // the loop below 20x. This is because several 32-bit ops can be // done in parallel, but only fewer 64-bit ones. uint32_t pos = result - 1; while (v >= 10) { // Keep these together so a peephole optimization "sees" them and // computes them in one shot. auto const q = v / 10; auto const r = static_cast(v % 10); buffer[pos--] = '0' + r; v = q; } // Last digit is trivial to handle buffer[pos] = static_cast(v) + '0'; return result; } /** * A single char gets appended. */ template void toAppend(char value, Tgt * result) { *result += value; } template constexpr typename std::enable_if< std::is_same::value, size_t>::type estimateSpaceNeeded(T) { return 1; } /** * Everything implicitly convertible to const char* gets appended. */ template typename std::enable_if< std::is_convertible::value && IsSomeString::value>::type toAppend(Src value, Tgt * result) { // Treat null pointers like an empty string, as in: // operator<<(std::ostream&, const char*). const char* c = value; if (c) { result->append(value); } } template typename std::enable_if::value, size_t>:: type estimateSpaceNeeded(Src value) { const char *c = value; if (c) { return folly::StringPiece(value).size(); }; return 0; } template typename std::enable_if< (std::is_convertible::value || IsSomeString::value) && !std::is_convertible::value, size_t>::type estimateSpaceNeeded(Src value) { return folly::StringPiece(value).size(); } template <> inline size_t estimateSpaceNeeded(std::nullptr_t /* value */) { return 0; } template typename std::enable_if< std::is_pointer::value && IsSomeString>::value, size_t>::type estimateSpaceNeeded(Src value) { return value->size(); } /** * Strings get appended, too. */ template typename std::enable_if< IsSomeString::value && IsSomeString::value>::type toAppend(const Src& value, Tgt * result) { result->append(value); } /** * and StringPiece objects too */ template typename std::enable_if< IsSomeString::value>::type toAppend(StringPiece value, Tgt * result) { result->append(value.data(), value.size()); } /** * There's no implicit conversion from fbstring to other string types, * so make a specialization. */ template typename std::enable_if< IsSomeString::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 void toAppend(__int128 value, Tgt * result) { typedef unsigned __int128 Usrc; char buffer[detail::digitsEnough() + 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 void toAppend(unsigned __int128 value, Tgt * result) { char buffer[detail::digitsEnough()]; size_t p; p = detail::unsafeTelescope128(buffer, sizeof(buffer), value); result->append(buffer + p, buffer + sizeof(buffer)); } template constexpr typename std::enable_if< std::is_same::value, size_t>::type estimateSpaceNeeded(T) { return detail::digitsEnough<__int128>(); } template constexpr typename std::enable_if< std::is_same::value, size_t>::type estimateSpaceNeeded(T) { return detail::digitsEnough(); } #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. 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 typename std::enable_if< std::is_integral::value && std::is_signed::value && IsSomeString::value && sizeof(Src) >= 4>::type toAppend(Src value, Tgt * result) { char buffer[20]; if (value < 0) { result->push_back('-'); result->append(buffer, uint64ToBufferUnsafe(-uint64_t(value), buffer)); } else { result->append(buffer, uint64ToBufferUnsafe(value, buffer)); } } template typename std::enable_if< std::is_integral::value && std::is_signed::value && sizeof(Src) >= 4 && sizeof(Src) < 16, size_t>::type estimateSpaceNeeded(Src value) { if (value < 0) { // When "value" is the smallest negative, negating it would evoke // undefined behavior, so, instead of writing "-value" below, we write // "~static_cast(value) + 1" return 1 + digits10(~static_cast(value) + 1); } return digits10(static_cast(value)); } /** * As above, but for uint32_t and uint64_t. */ template typename std::enable_if< std::is_integral::value && !std::is_signed::value && IsSomeString::value && sizeof(Src) >= 4>::type toAppend(Src value, Tgt * result) { char buffer[20]; result->append(buffer, uint64ToBufferUnsafe(value, buffer)); } template typename std::enable_if< std::is_integral::value && !std::is_signed::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 typename std::enable_if< std::is_integral::value && IsSomeString::value && sizeof(Src) < 4>::type toAppend(Src value, Tgt * result) { typedef typename std::conditional::value, int64_t, uint64_t>::type Intermediate; toAppend(static_cast(value), result); } template typename std::enable_if< std::is_integral::value && sizeof(Src) < 4 && !std::is_same::value, size_t>::type estimateSpaceNeeded(Src value) { typedef typename std::conditional::value, int64_t, uint64_t>::type Intermediate; return estimateSpaceNeeded(static_cast(value)); } /** * Enumerated values get appended as integers. */ template typename std::enable_if< std::is_enum::value && IsSomeString::value>::type toAppend(Src value, Tgt * result) { toAppend( static_cast::type>(value), result); } template typename std::enable_if< std::is_enum::value, size_t>::type estimateSpaceNeeded(Src value) { return estimateSpaceNeeded( static_cast::type>(value)); } /******************************************************************************* * Conversions from floating-point types to string types. ******************************************************************************/ namespace detail { constexpr int kConvMaxDecimalInShortestLow = -6; constexpr int kConvMaxDecimalInShortestHigh = 21; } // folly::detail /** Wrapper around DoubleToStringConverter **/ template typename std::enable_if< std::is_floating_point::value && IsSomeString::value>::type toAppend( Src value, Tgt * result, double_conversion::DoubleToStringConverter::DtoaMode mode, unsigned int numDigits) { using namespace double_conversion; DoubleToStringConverter conv(DoubleToStringConverter::NO_FLAGS, "Infinity", "NaN", 'E', detail::kConvMaxDecimalInShortestLow, detail::kConvMaxDecimalInShortestHigh, 6, // max leading padding zeros 1); // max trailing padding zeros char buffer[256]; StringBuilder builder(buffer, sizeof(buffer)); switch (mode) { case DoubleToStringConverter::SHORTEST: conv.ToShortest(value, &builder); break; case DoubleToStringConverter::FIXED: conv.ToFixed(value, numDigits, &builder); break; default: CHECK(mode == DoubleToStringConverter::PRECISION); conv.ToPrecision(value, numDigits, &builder); break; } const size_t length = builder.position(); builder.Finalize(); result->append(buffer, length); } /** * As above, but for floating point */ template typename std::enable_if< std::is_floating_point::value && IsSomeString::value>::type toAppend(Src value, Tgt * result) { toAppend( value, result, double_conversion::DoubleToStringConverter::SHORTEST, 0); } /** * Upper bound of the length of the output from * DoubleToStringConverter::ToShortest(double, StringBuilder*), * as used in toAppend(double, string*). */ template typename std::enable_if< std::is_floating_point::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::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 struct HasLengthEstimator : std::false_type {}; template constexpr typename std::enable_if< !std::is_fundamental::value #if FOLLY_HAVE_INT128_T // On OSX 10.10, is_fundamental<__int128> is false :-O && !std::is_same<__int128, Src>::value && !std::is_same::value #endif && !IsSomeString::value && !std::is_convertible::value && !std::is_convertible::value && !std::is_enum::value && !HasLengthEstimator::value, size_t>::type estimateSpaceNeeded(const Src&) { return sizeof(Src) + 1; // dumbest best effort ever? } namespace detail { template typename std::enable_if::value, size_t>::type estimateSpaceToReserve(size_t sofar, Tgt*) { return sofar; } template size_t estimateSpaceToReserve(size_t sofar, const T& v, const Ts&... vs) { return estimateSpaceToReserve(sofar + estimateSpaceNeeded(v), vs...); } template void reserveInTarget(const Ts&...vs) { getLastElement(vs...)->reserve(estimateSpaceToReserve(0, vs...)); } template 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, static_cast(nullptr)); getLastElement(vs...)->reserve(estimateSpaceToReserve(fordelim, vs...)); } /** * Variadic base case: append one element */ template typename std::enable_if< IsSomeString::type> ::value>::type toAppendStrImpl(const T& v, Tgt result) { toAppend(v, result); } template typename std::enable_if< sizeof...(Ts) >= 2 && IsSomeString::type>::type>::value>::type toAppendStrImpl(const T& v, const Ts&... vs) { toAppend(v, getLastElement(vs...)); toAppendStrImpl(vs...); } template typename std::enable_if< IsSomeString::type>::value>::type toAppendDelimStrImpl(const Delimiter& /* delim */, const T& v, Tgt result) { toAppend(v, result); } template typename std::enable_if< sizeof...(Ts) >= 2 && IsSomeString::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). * * Custom implementations of toAppend() can be provided in the same namespace as * the type to customize printing. estimateSpaceNeed() may also be provided to * avoid reallocations in toAppendFit(): * * namespace other_namespace { * * template * void toAppend(const OtherType&, String* out); * * // optional * size_t estimateSpaceNeeded(const OtherType&); * * } */ template typename std::enable_if< sizeof...(Ts) >= 3 && IsSomeString::type>::type>::value>::type toAppend(const Ts&... vs) { ::folly::detail::toAppendStrImpl(vs...); } #ifdef _MSC_VER // Special case pid_t on MSVC, because it's a void* rather than an // integral type. We can't do a global special case because this is already // dangerous enough (as most pointers will implicitly convert to a void*) // just doing it for MSVC. template void toAppend(const pid_t a, Tgt* res) { toAppend(uint64_t(a), res); } #endif /** * 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 typename std::enable_if::type>::type>::value>::type toAppendFit(const Ts&... vs) { ::folly::detail::reserveInTarget(vs...); toAppend(vs...); } template void toAppendFit(const Ts&) {} /** * Variadic base case: do nothing. */ template typename std::enable_if::value>::type toAppend( Tgt* /* result */) {} /** * Variadic base case: do nothing. */ template typename std::enable_if::value>::type toAppendDelim( const Delimiter& /* delim */, Tgt* /* result */) {} /** * 1 element: same as toAppend. */ template typename std::enable_if::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 typename std::enable_if< sizeof...(Ts) >= 3 && IsSomeString::type>::type>::value>::type toAppendDelim(const Delimiter& delim, const Ts&... vs) { detail::toAppendDelimStrImpl(delim, vs...); } /** * Detail in comment for toAppendFit */ template typename std::enable_if::type>::type>::value>::type toAppendDelimFit(const Delimiter& delim, const Ts&... vs) { detail::reserveInTargetDelim(delim, vs...); toAppendDelim(delim, vs...); } template void toAppendDelimFit(const De&, const Ts&) {} /** * to(v1, v2, ...) uses toAppend() (see below) as back-end * for all types. */ template typename std::enable_if< IsSomeString::value && (sizeof...(Ts) != 1 || !std::is_same::type>:: value), Tgt>::type to(const Ts&... vs) { Tgt result; toAppendFit(vs..., &result); return result; } /** * Special version of to for floating point. When calling * folly::to(double), generic implementation above will * firstly reserve 24 (or 25 when negative value) bytes. This will * introduce a malloc call for most mainstream string implementations. * * But for most cases, a floating point doesn't need 24 (or 25) bytes to * be converted as a string. * * This special version will not do string reserve. */ template typename std::enable_if< IsSomeString::value && std::is_floating_point::value, Tgt>::type to(Src value) { Tgt result; toAppend(value, &result); return result; } /** * toDelim(SomeString str) returns itself. */ template typename std::enable_if::value && std::is_same::value, Tgt>::type toDelim(const Delim& /* delim */, const Src& value) { return value; } /** * toDelim(delim, v1, v2, ...) uses toAppendDelim() as * back-end for all types. */ template typename std::enable_if< IsSomeString::value && (sizeof...(Ts) != 1 || !std::is_same::type>:: value), Tgt>::type toDelim(const Delim& delim, const Ts&... vs) { Tgt result; toAppendDelimFit(delim, vs..., &result); return result; } /******************************************************************************* * Conversions from string types to integral types. ******************************************************************************/ namespace detail { Expected str_to_bool(StringPiece* src) noexcept; template Expected str_to_floating(StringPiece* src) noexcept; extern template Expected str_to_floating( StringPiece* src) noexcept; extern template Expected str_to_floating( StringPiece* src) noexcept; template Expected digits_to(const char* b, const char* e) noexcept; extern template Expected digits_to( const char*, const char*) noexcept; extern template Expected digits_to( const char*, const char*) noexcept; extern template Expected digits_to(const char*, const char*) noexcept; extern template Expected digits_to( const char*, const char*) noexcept; extern template Expected digits_to(const char*, const char*) noexcept; extern template Expected digits_to( const char*, const char*) noexcept; extern template Expected digits_to( const char*, const char*) noexcept; extern template Expected digits_to( const char*, const char*) noexcept; extern template Expected digits_to(const char*, const char*) noexcept; extern template Expected digits_to( const char*, const char*) noexcept; extern template Expected digits_to(const char*, const char*) noexcept; #if FOLLY_HAVE_INT128_T extern template Expected<__int128, ConversionCode> digits_to<__int128>( const char*, const char*) noexcept; extern template Expected digits_to(const char*, const char*) noexcept; #endif template Expected str_to_integral(StringPiece* src) noexcept; extern template Expected str_to_integral( StringPiece* src) noexcept; extern template Expected str_to_integral(StringPiece* src) noexcept; extern template Expected str_to_integral(StringPiece* src) noexcept; extern template Expected str_to_integral( StringPiece* src) noexcept; extern template Expected str_to_integral(StringPiece* src) noexcept; extern template Expected str_to_integral( StringPiece* src) noexcept; extern template Expected str_to_integral(StringPiece* src) noexcept; extern template Expected str_to_integral( StringPiece* src) noexcept; extern template Expected str_to_integral(StringPiece* src) noexcept; extern template Expected str_to_integral( StringPiece* src) noexcept; extern template Expected str_to_integral(StringPiece* src) noexcept; #if FOLLY_HAVE_INT128_T extern template Expected<__int128, ConversionCode> str_to_integral<__int128>( StringPiece* src) noexcept; extern template Expected str_to_integral(StringPiece* src) noexcept; #endif template typename std:: enable_if::value, Expected>::type convertTo(StringPiece* src) noexcept { return str_to_bool(src); } template typename std::enable_if< std::is_floating_point::value, Expected>::type convertTo(StringPiece* src) noexcept { return str_to_floating(src); } template typename std::enable_if< std::is_integral::value && !std::is_same::value, Expected>::type convertTo(StringPiece* src) noexcept { return str_to_integral(src); } } // namespace detail /** * String represented as a pair of pointers to char to unsigned * integrals. Assumes NO whitespace before or after. */ template typename std::enable_if< std::is_integral::value && !std::is_same::value, Expected>::type tryTo(const char* b, const char* e) { return detail::digits_to(b, e); } template typename std::enable_if< std::is_integral::value && !std::is_same::value, Tgt>::type to(const char* b, const char* e) { return tryTo(b, e).thenOrThrow( [](Tgt res) { return res; }, [=](ConversionCode code) { return makeConversionError(code, StringPiece(b, e)); }); } /******************************************************************************* * Conversions from string types to arithmetic types. ******************************************************************************/ /** * Parsing strings to numeric types. */ template FOLLY_WARN_UNUSED_RESULT inline typename std::enable_if< std::is_arithmetic::value, Expected>::type parseTo(StringPiece src, Tgt& out) { return detail::convertTo(&src).then( [&](Tgt res) { return void(out = res), src; }); } /******************************************************************************* * Integral / Floating Point to integral / Floating Point ******************************************************************************/ namespace detail { /** * Checked conversion from integral to integral. The checks are only * performed when meaningful, e.g. conversion from int to long goes * unchecked. */ template typename std::enable_if< std::is_integral::value && !std::is_same::value && !std::is_same::value && std::is_integral::value, Expected>::type convertTo(const Src& value) noexcept { /* static */ if ( std::numeric_limits::max() < std::numeric_limits::max()) { if (greater_than::max()>(value)) { return makeUnexpected(ConversionCode::ARITH_POSITIVE_OVERFLOW); } } /* static */ if ( std::is_signed::value && (!std::is_signed::value || sizeof(Src) > sizeof(Tgt))) { if (less_than::min()>(value)) { return makeUnexpected(ConversionCode::ARITH_NEGATIVE_OVERFLOW); } } return static_cast(value); } /** * Checked conversion from floating to floating. The checks are only * performed when meaningful, e.g. conversion from float to double goes * unchecked. */ template typename std::enable_if< std::is_floating_point::value && std::is_floating_point::value && !std::is_same::value, Expected>::type convertTo(const Src& value) noexcept { /* static */ if ( std::numeric_limits::max() < std::numeric_limits::max()) { if (value > std::numeric_limits::max()) { return makeUnexpected(ConversionCode::ARITH_POSITIVE_OVERFLOW); } if (value < std::numeric_limits::lowest()) { return makeUnexpected(ConversionCode::ARITH_NEGATIVE_OVERFLOW); } } return boost::implicit_cast(value); } /** * Check if a floating point value can safely be converted to an * integer value without triggering undefined behaviour. */ template inline typename std::enable_if< std::is_floating_point::value && std::is_integral::value && !std::is_same::value, bool>::type checkConversion(const Src& value) { constexpr Src tgtMaxAsSrc = static_cast(std::numeric_limits::max()); constexpr Src tgtMinAsSrc = static_cast(std::numeric_limits::min()); if (value >= tgtMaxAsSrc) { if (value > tgtMaxAsSrc) { return false; } const Src mmax = folly::nextafter(tgtMaxAsSrc, Src()); if (static_cast(value - mmax) > std::numeric_limits::max() - static_cast(mmax)) { return false; } } else if (std::is_signed::value && value <= tgtMinAsSrc) { if (value < tgtMinAsSrc) { return false; } const Src mmin = folly::nextafter(tgtMinAsSrc, Src()); if (static_cast(value - mmin) < std::numeric_limits::min() - static_cast(mmin)) { return false; } } return true; } // Integers can always safely be converted to floating point values template constexpr typename std::enable_if< std::is_integral::value && std::is_floating_point::value, bool>::type checkConversion(const Src&) { return true; } // Also, floating point values can always be safely converted to bool // Per the standard, any floating point value that is not zero will yield true template constexpr typename std::enable_if< std::is_floating_point::value && std::is_same::value, bool>::type checkConversion(const Src&) { return true; } /** * Checked conversion from integral to floating point and back. The * result must be convertible back to the source type without loss of * precision. This seems Draconian but sometimes is what's needed, and * complements existing routines nicely. For various rounding * routines, see . */ template typename std::enable_if< (std::is_integral::value && std::is_floating_point::value) || (std::is_floating_point::value && std::is_integral::value), Expected>::type convertTo(const Src& value) noexcept { if (LIKELY(checkConversion(value))) { Tgt result = static_cast(value); if (LIKELY(checkConversion(result))) { Src witness = static_cast(result); if (LIKELY(value == witness)) { return result; } } } return makeUnexpected(ConversionCode::ARITH_LOSS_OF_PRECISION); } template inline std::string errorValue(const Src& value) { #ifdef FOLLY_HAS_RTTI return to("(", demangle(typeid(Tgt)), ") ", value); #else return to(value); #endif } template using IsArithToArith = std::integral_constant< bool, !std::is_same::value && !std::is_same::value && std::is_arithmetic::value && std::is_arithmetic::value>; } // namespace detail template typename std::enable_if< detail::IsArithToArith::value, Expected>::type tryTo(const Src& value) noexcept { return detail::convertTo(value); } template typename std::enable_if::value, Tgt>::type to( const Src& value) { return tryTo(value).thenOrThrow( [](Tgt res) { return res; }, [&](ConversionCode e) { return makeConversionError(e, detail::errorValue(value)); }); } /******************************************************************************* * Custom Conversions * * Any type can be used with folly::to by implementing parseTo. The * implementation should be provided in the namespace of the type to facilitate * argument-dependent lookup: * * namespace other_namespace { * ::folly::Expected<::folly::StringPiece, SomeErrorCode> * parseTo(::folly::StringPiece, OtherType&) noexcept; * } ******************************************************************************/ template FOLLY_WARN_UNUSED_RESULT typename std::enable_if< std::is_enum::value, Expected>::type parseTo(StringPiece in, T& out) noexcept { typename std::underlying_type::type tmp{}; auto restOrError = parseTo(in, tmp); out = static_cast(tmp); // Harmless if parseTo fails return restOrError; } FOLLY_WARN_UNUSED_RESULT inline Expected parseTo( StringPiece in, StringPiece& out) noexcept { out = in; return StringPiece{in.end(), in.end()}; } FOLLY_WARN_UNUSED_RESULT inline Expected parseTo( StringPiece in, std::string& out) { out.clear(); out.append(in.data(), in.size()); // TODO try/catch? return StringPiece{in.end(), in.end()}; } FOLLY_WARN_UNUSED_RESULT inline Expected parseTo( StringPiece in, fbstring& out) { out.clear(); out.append(in.data(), in.size()); // TODO try/catch? return StringPiece{in.end(), in.end()}; } namespace detail { template using ParseToResult = decltype(parseTo(StringPiece{}, std::declval())); struct CheckTrailingSpace { Expected operator()(StringPiece sp) const { auto e = enforceWhitespaceErr(sp); if (UNLIKELY(e != ConversionCode::SUCCESS)) return makeUnexpected(e); return unit; } }; template struct ReturnUnit { template constexpr Expected operator()(T&&) const { return unit; } }; // Older versions of the parseTo customization point threw on error and // returned void. Handle that. template inline typename std::enable_if< std::is_void>::value, Expected>::type parseToWrap(StringPiece sp, Tgt& out) { parseTo(sp, out); return StringPiece(sp.end(), sp.end()); } template inline typename std::enable_if< !std::is_void>::value, ParseToResult>::type parseToWrap(StringPiece sp, Tgt& out) { return parseTo(sp, out); } template using ParseToError = ExpectedErrorType()))>; } // namespace detail /** * String or StringPiece to target conversion. Accepts leading and trailing * whitespace, but no non-space trailing characters. */ template inline typename std::enable_if< !std::is_same::value, Expected>>::type tryTo(StringPiece src) { Tgt result{}; using Error = detail::ParseToError; using Check = typename std::conditional< std::is_arithmetic::value, detail::CheckTrailingSpace, detail::ReturnUnit>::type; return parseTo(src, result).then(Check(), [&](Unit) { return std::move(result); }); } template inline typename std::enable_if::value, Tgt>::type to(StringPiece src) { Tgt result{}; using Error = detail::ParseToError; using Check = typename std::conditional< std::is_arithmetic::value, detail::CheckTrailingSpace, detail::ReturnUnit>::type; auto tmp = detail::parseToWrap(src, result); return tmp .thenOrThrow(Check(), [&](Error e) { throw makeConversionError(e, src); }) .thenOrThrow( [&](Unit) { return std::move(result); }, [&](Error e) { throw makeConversionError(e, tmp.value()); }); } /** * tryTo/to that take the strings by pointer so the caller gets information * about how much of the string was consumed by the conversion. These do not * check for trailing whitepsace. */ template Expected> tryTo(StringPiece* src) { Tgt result; return parseTo(*src, result).then([&, src](StringPiece sp) -> Tgt { *src = sp; return std::move(result); }); } template Tgt to(StringPiece* src) { Tgt result{}; using Error = detail::ParseToError; return parseTo(*src, result) .thenOrThrow( [&, src](StringPiece sp) -> Tgt { *src = sp; return std::move(result); }, [=](Error e) { return makeConversionError(e, *src); }); } /******************************************************************************* * Enum to anything and back ******************************************************************************/ template typename std::enable_if< std::is_enum::value && !std::is_same::value, Expected>::type tryTo(const Src& value) { using I = typename std::underlying_type::type; return tryTo(static_cast(value)); } template typename std::enable_if< std::is_enum::value && !std::is_same::value, Tgt>::type tryTo(const Src& value) { using I = typename std::underlying_type::type; return tryTo(value).then([](I i) { return static_cast(i); }); } template typename std::enable_if< std::is_enum::value && !std::is_same::value, Tgt>::type to(const Src& value) { return to(static_cast::type>(value)); } template typename std::enable_if< std::is_enum::value && !std::is_same::value, Tgt>::type to(const Src & value) { return static_cast(to::type>(value)); } } // namespace folly