/* * Copyright (c) Meta Platforms, Inc. and affiliates. * * 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. */ // // Docs: https://fburl.com/fbcref_conv // /** * Conv provides the ubiquitous method `to<TargetType>(source)`, along with * a few other generic interfaces for converting objects to and from * string-like types (std::string, fbstring, StringPiece), as well as * range-checked conversions between numeric and enum types. The mechanisms are * extensible, so that user-specified types can add folly::to support. * * folly::to<std::string>(123) * // "123" * ******************************************************************************* * ## TYPE -> STRING CONVERSIONS ******************************************************************************* * You can call the `to<std::string>` or `to<fbstring>`. These are variadic * functions that convert their arguments to strings, and concatenate them to * form a result. So, for example, * * auto str = to<std::string>(123, "456", 789); * * Sets str to `"123456789"`. * * In addition to just concatenating the arguments, related functions can * delimit them with some string: `toDelim<std::string>(",", "123", 456, "789")` * will return the string `"123,456,789"`. * * toAppend does not return a string; instead, it takes a pointer to a string as * its last argument, and appends the result of the concatenation into it: * std::string str = "123"; * toAppend(456, "789", &str); // Now str is "123456789". * * The toAppendFit function acts like toAppend, but it precalculates the size * required to perform the append operation, and reserves that space in the * output string before actually inserting its arguments. This can sometimes * save on string expansion, but beware: appending to the same string many times * with toAppendFit is likely a pessimization, since it will resize the string * once per append. * * The combination of the append and delim variants also exist: toAppendDelim * and toAppendDelimFit are defined, with the obvious semantics. * ******************************************************************************* * ## STRING -> TYPE CONVERSIONS ******************************************************************************* * Going in the other direction, and parsing a string into a C++ type, is also * supported: * to<int>("123"); // Returns 123. * * Out of range (e.g. `to<std::uint8_t>("1000")`), or invalidly formatted (e.g. * `to<int>("four")`) inputs will throw. If throw-on-error is undesirable (for * instance: you're dealing with untrusted input, and want to protect yourself * from users sending you down a very slow exception-throwing path), you can use * `tryTo<T>`, which will return an `Expected<T, ConversionCode>`. * * There are overloads of to() and tryTo() that take a `StringPiece*`. These * parse out a type from the beginning of a string, and modify the passed-in * StringPiece to indicate the portion of the string not consumed. * ******************************************************************************* * ## NUMERIC / ENUM CONVERSIONS ******************************************************************************* * Conv also supports a `to<T>(S)` overload, where T and S are numeric or enum * types, that checks to see that the target type can represent its argument, * and will throw if it cannot. This includes cases where a floating point to * integral conversion is attempted on a value with a non-zero fractional * component, and integral to floating point conversions that would lose * precision. Enum conversions are range-checked for the underlying type of the * enum, but there is no check that the input value is a valid choice of enum * value. * ******************************************************************************* * ## CUSTOM TYPE CONVERSIONS ******************************************************************************* * Users may customize the string conversion functionality for their own data * types. The key functions you should implement are: * // Two functions to allow conversion to your type from a string. * Expected<StringPiece, ConversionCode> parseTo(folly::StringPiece in, * YourType& out); * YourErrorType makeConversionError(YourErrorType in, StringPiece in); * // Two functions to allow conversion from your type to a string. * template <class String> * void toAppend(const YourType& in, String* out); * size_t estimateSpaceNeeded(const YourType& in); * * These are documented below, inline. * * @file Conv.h */ #pragma once #include <algorithm> #include <cassert> #include <cctype> #include <climits> #include <cmath> #include <cstddef> #include <limits> #include <optional> #include <stdexcept> #include <string> #include <system_error> #include <tuple> #include <type_traits> #include <utility> #if __has_include(<charconv>) #include <charconv> #endif #include <double-conversion/double-conversion.h> // V8 JavaScript implementation #include <folly/CPortability.h> #include <folly/Demangle.h> #include <folly/Expected.h> #include <folly/FBString.h> #include <folly/Likely.h> #include <folly/Portability.h> #include <folly/Range.h> #include <folly/Traits.h> #include <folly/Unit.h> #include <folly/Utility.h> #include <folly/lang/Exception.h> #include <folly/lang/Pretty.h> #include <folly/lang/ToAscii.h> #include <folly/portability/Math.h> // FOLLY_CONV_AVALIABILITY_TO_CHARS_FLOATING_POINT indicates that // std::to_chars for floating point is available #if (defined(__cpp_lib_to_chars) && __cpp_lib_to_chars >= 201611L) #define FOLLY_CONV_AVALIABILITY_TO_CHARS_FLOATING_POINT … #elif defined(_LIBCPP_HAS_NO_VENDOR_AVAILABILITY_ANNOTATIONS) && \ defined(_LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT) #define FOLLY_CONV_AVALIABILITY_TO_CHARS_FLOATING_POINT … #elif defined(__APPLE__) && \ ((defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && \ __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 130300) || \ (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && \ __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 160300) || \ (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && \ __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ >= 160300) || \ (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && \ __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ >= 90300)) // Apple introduces std::to_chars & std::from_chars support for floating // point types for: macOS 13.3, iOS 16.3, tvOS 16.3, watchOS 9.3. // https://developer.apple.com/xcode/cpp/#c++17 // __builtin_available(macOS 13.3, iOS 16.3, tvOS 16.3, watchOS 9.3, *)) { // The avaliability attributes are marked as strict, so preprocessor // conditionals must be used to check if it's available. #define FOLLY_CONV_AVALIABILITY_TO_CHARS_FLOATING_POINT … #else #define FOLLY_CONV_AVALIABILITY_TO_CHARS_FLOATING_POINT … #endif // FOLLY_CONV_USE_TO_CHARS set to 1 indicates that std::to_chars will be used // because it's available and it was requested. #if defined(FOLLY_CONV_DTOA_TO_CHARS) && FOLLY_CONV_DTOA_TO_CHARS == 1 && \ defined(FOLLY_CONV_AVALIABILITY_TO_CHARS_FLOATING_POINT) && \ FOLLY_CONV_AVALIABILITY_TO_CHARS_FLOATING_POINT == 1 #define FOLLY_CONV_USE_TO_CHARS … #else #define FOLLY_CONV_USE_TO_CHARS … #endif namespace folly { // Keep this in sync with kErrorStrings in Conv.cpp enum class ConversionCode : unsigned char { … }; struct FOLLY_EXPORT ConversionErrorBase : std::range_error { … }; class FOLLY_EXPORT ConversionError : public ConversionErrorBase { … }; /** * 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 input); namespace detail { /** * Enforce that the suffix following a number is made up only of whitespace. */ inline ConversionCode enforceWhitespaceErr(StringPiece sp) { … } /** * Keep this implementation around for prettyToDouble(). */ inline void enforceWhitespace(StringPiece sp) { … } } // namespace detail /** * @overloadbrief to, but return an Expected * * The identity conversion function. * tryTo<T>(T) returns itself for all types T. */ template <class Tgt, class Src> typename std::enable_if< std::is_same<Tgt, typename std::decay<Src>::type>::value, Expected<Tgt, ConversionCode>>::type tryTo(Src&& value) { … } /** * @overloadbrief Convert from one type to another. */ template <class Tgt, class Src> typename std::enable_if< std::is_same<Tgt, typename std::decay<Src>::type>::value, Tgt>::type to(Src&& 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 <class Tgt, class Src> typename std::enable_if< is_arithmetic_v<Src> && !std::is_same<Tgt, Src>::value && std::is_same<Tgt, bool>::value, Expected<Tgt, ConversionCode>>::type tryTo(const Src& value) { … } template <class Tgt, class Src> typename std::enable_if< is_arithmetic_v<Src> && !std::is_same<Tgt, Src>::value && std::is_same<Tgt, bool>::value, Tgt>::type to(const Src& value) { … } /** * Anything to string */ namespace detail { LastElement; #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 <typename... Ts, typename R = LastElement<Ts...>> const R& getLastElement(const Ts&... ts) { return std::get<sizeof...(Ts) - 1>(std::forward_as_tuple(ts...)); } inline void getLastElement() {} #else template <typename...> struct LastElementImpl; template <> struct LastElementImpl<> { … }; LastElementImpl<Ign, Igns...>; template <typename... Ts, typename R = LastElement<Ts...>> const R& getLastElement(const Ts&... ts) { … } #endif } // namespace detail /** * Conversions from integral types to string types. */ #if FOLLY_HAVE_INT128_T namespace detail { template <typename IntegerType> constexpr unsigned int digitsEnough() { // digits10 returns the number of decimal digits that this type can represent, // not the number of characters required for the max value, so we need to add // one. ex: char digits10 returns 2, because 256-999 cannot be represented, // but we need 3. auto const digits10 = std::numeric_limits<IntegerType>::digits10; return static_cast<unsigned int>(digits10) + 1; } inline size_t unsafeTelescope128(char* outb, char* oute, unsigned __int128 x) { using Usrc = unsigned __int128; // Decompose the input into at most 3 components using the largest power-of-10 // base that fits in a 64-bit unsigned integer, and then convert the // components using 64-bit arithmetic and concatenate them. constexpr static auto kBase = UINT64_C(10'000'000'000'000'000'000); constexpr static size_t kBaseDigits = 19; size_t p = 0; const auto leading = [&](Usrc v) { assert(v >> 64 == 0); p = detail::to_ascii_with_route<10, to_ascii_alphabet_lower>( outb, oute, static_cast<uint64_t>(v)); }; const auto append = [&](uint64_t v) { assert(v < kBase); assert(outb + p + kBaseDigits <= oute); auto v64 = static_cast<uint64_t>(v); detail::to_ascii_with_route<10, to_ascii_alphabet_lower>( outb + p, kBaseDigits, v64); p += kBaseDigits; }; if (x >> 64 > 0) { const auto rem = static_cast<uint64_t>(x % kBase); x /= kBase; if (x >> 64 > 0) { const auto rem2 = static_cast<uint64_t>(x % kBase); x /= kBase; leading(x); append(rem2); append(rem); return p; } leading(x); append(rem); return p; } leading(x); return p; } } // namespace detail #endif /** * @overloadbrief Appends conversion to string. * * A single char gets appended. */ template <class Tgt> void toAppend(char value, Tgt* result) { … } /** * @overloadbrief Estimates the number of characters in a value's string * representation. */ template <class T> constexpr typename std::enable_if<std::is_same<T, char>::value, size_t>::type estimateSpaceNeeded(T) { … } template <size_t N> constexpr size_t estimateSpaceNeeded(const char (&)[N]) { … } /** * Everything implicitly convertible to const char* gets appended. */ template <class Tgt, class Src> typename std::enable_if< std::is_convertible<Src, const char*>::value && IsSomeString<Tgt>::value>::type toAppend(Src value, Tgt* result) { … } template <class Src> typename std::enable_if<std::is_convertible<Src, const char*>::value, size_t>:: type estimateSpaceNeeded(Src value) { … } template <class Src> typename std::enable_if<IsSomeString<Src>::value, size_t>::type estimateSpaceNeeded(Src const& value) { … } 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) { … } template <> inline size_t estimateSpaceNeeded(std::nullptr_t /* value */) { … } template <class Src> typename std::enable_if< std::is_pointer<Src>::value && IsSomeString<std::remove_pointer<Src>>::value, size_t>::type estimateSpaceNeeded(Src value) { … } /** * Strings get appended, too. */ template <class Tgt, class Src> typename std::enable_if< IsSomeString<Src>::value && IsSomeString<Tgt>::value>::type toAppend(const Src& value, Tgt* result) { … } /** * and StringPiece objects too */ template <class Tgt> typename std::enable_if<IsSomeString<Tgt>::value>::type toAppend( StringPiece value, Tgt* result) { … } /** * There's no implicit conversion from fbstring to other string types, * so make a specialization. */ template <class Tgt> typename std::enable_if<IsSomeString<Tgt>::value>::type toAppend( const fbstring& value, Tgt* result) { … } #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]; const auto oute = buffer + sizeof(buffer); size_t p; if (value < 0) { buffer[0] = '-'; p = 1 + detail::unsafeTelescope128(buffer + 1, oute, -Usrc(value)); } else { p = detail::unsafeTelescope128(buffer, oute, value); } result->append(buffer, p); } template <class Tgt> void toAppend(unsigned __int128 value, Tgt* result) { char buffer[detail::digitsEnough<unsigned __int128>()]; size_t p = detail::unsafeTelescope128(buffer, buffer + sizeof(buffer), value); result->append(buffer, p); } 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. 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< is_integral_v<Src> && is_signed_v<Src> && IsSomeString<Tgt>::value && sizeof(Src) >= 4>::type toAppend(Src value, Tgt* result) { … } template <class Src> typename std::enable_if< is_integral_v<Src> && is_signed_v<Src> && sizeof(Src) >= 4 && sizeof(Src) < 16, size_t>::type estimateSpaceNeeded(Src value) { … } /** * As above, but for uint32_t and uint64_t. */ template <class Tgt, class Src> typename std::enable_if< is_integral_v<Src> && !is_signed_v<Src> && IsSomeString<Tgt>::value && sizeof(Src) >= 4>::type toAppend(Src value, Tgt* result) { … } template <class Src> typename std::enable_if< is_integral_v<Src> && !is_signed_v<Src> && sizeof(Src) >= 4 && sizeof(Src) < 16, size_t>::type estimateSpaceNeeded(Src 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< is_integral_v<Src> && IsSomeString<Tgt>::value && sizeof(Src) < 4>::type toAppend(Src value, Tgt* result) { … } template <class Src> typename std::enable_if< is_integral_v<Src> && sizeof(Src) < 4 && !std::is_same<Src, char>::value, size_t>::type estimateSpaceNeeded(Src value) { … } /** * 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) { … } template <class Src> typename std::enable_if<std::is_enum<Src>::value, size_t>::type estimateSpaceNeeded(Src value) { … } /** * Conversions from floating-point types to string types. */ /// Operating mode for the floating point type version of /// `folly::ToAppend`. This is modeled after /// `double_conversion::DoubleToStringConverter::DtoaMode`. /// Dtoa is an acryonym for Double to ASCII. enum class DtoaMode { … }; /// Flags for the floating point type version of `folly::ToAppend`. /// This is modeled after `double_conversion::DoubleToStringConverter::Flags`. /// Dtoa is an acryonym for Double to ASCII. /// This enum is used to store bit wise flags, so a variable of this type may be /// a bitwise combination of these definitions. enum class DtoaFlags { … }; constexpr DtoaFlags operator|(DtoaFlags a, DtoaFlags b) { … } constexpr DtoaFlags operator&(DtoaFlags a, DtoaFlags b) { … } namespace detail { constexpr int kConvMaxDecimalInShortestLow = …; /// 10^kConvMaxDecimalInShortestLow. Replace with constexpr std::pow in C++26. constexpr double kConvMaxDecimalInShortestLowValue = …; constexpr int kConvMaxDecimalInShortestHigh = …; /// 10^kConvMaxDecimalInShortestHigh. Replace with constexpr std::pow in C++26. constexpr double kConvMaxDecimalInShortestHighValue = …; constexpr int kBase10MaximalLength = …; enum class FloatToStringImpl { … }; #if defined(FOLLY_CONV_USE_TO_CHARS) && FOLLY_CONV_USE_TO_CHARS == 1 constexpr FloatToStringImpl kConvFloatToStringImpl = FloatToStringImpl::StdToChars; constexpr int kConvMaxFixedDigitsAfterPoint = 100; constexpr int kConvMaxPrecisionDigits = 120; #else constexpr FloatToStringImpl kConvFloatToStringImpl = …; constexpr int kConvMaxFixedDigitsAfterPoint = …; constexpr int kConvMaxPrecisionDigits = …; /// Converts `DtoaMode` to /// `double_conversion::DoubleToStringConverter::DtoaMode`. /// This is temporary until /// `double_conversion::DoubleToStringConverter::DtoaMode` is removed. constexpr double_conversion::DoubleToStringConverter::DtoaMode convert( DtoaMode mode) { … } /// Converts `DtoaFlags` to /// `double_conversion::DoubleToStringConverter::DtoaFlags`. /// This is temporary until /// `double_conversion::DoubleToStringConverter::DtoaFlags` is removed. constexpr double_conversion::DoubleToStringConverter::Flags convert( DtoaFlags flags) { … } /** * Wrapper around `double_conversion::DoubleToStringConverter`. */ template <class Tgt, class Src> typename std::enable_if< std::is_floating_point<Src>::value && IsSomeString<Tgt>::value>::type toAppendDoubleConversion( Src value, Tgt* result, DtoaMode mode, unsigned int numDigits, DtoaFlags flags = DtoaFlags::NO_FLAGS) { … } #endif // FOLLY_CONV_USE_TO_CHARS #if defined(FOLLY_CONV_AVALIABILITY_TO_CHARS_FLOATING_POINT) && \ FOLLY_CONV_AVALIABILITY_TO_CHARS_FLOATING_POINT == 1 /// Holds a set of `DtoaFlags` as a bitwise OR of the flags. /// It has convience member functions to check if a flag is set. struct DtoaFlagsSet { … }; /// This parses a decimal string into a structured format. /// For example, given "123.456e+7", this will create pointers to the integer, /// fractional, exponentional parts. /// /// The decimal string is passed in as a `char` buffer with begin and end /// pointers. The parsing will create pointers to parts of the decimal string. /// /// e.g., /// -123.456e+78 /// ABCDEFGHIJK /// negativeSign points to address A /// integerBegin points to address B /// integerEnd points to address E /// and so on... /// /// The is used to format the output of `std::to_chars` so that it is consistent /// with `double_conversion::DoubleToStringConverter`'s format. /// /// This also has helper member functions to identify parts needed to apply /// `DtoaMode::PRECISION` formating. class ParsedDecimal { … }; /// Formats the output from `std::to_chars` as if it came from /// `double_conversion::DoubleToStringConverter`. /// /// Specifically it adds support for: /// - EMIT_POSITIVE_EXPONENT_SIGN /// - EMIT_TRAILING_DECIMAL_POINT /// - EMIT_TRAILING_ZERO_AFTER_POINT /// - UNIQUE_ZERO /// - NO_TRAILING_ZERO /// - Captial E exponent sign (e.g., 1.23e4 -> 1.23E4) /// - Removes leading zeros in exponent (e.g., 1.23e04 -> 1.23e4) /// /// This modifies the result buffer in place to match the output format of /// `double_conversion::DoubleToStringConverter`. /// `resultBegin` is the begin pointer of the result from `std::to_chars`. /// `resultEnd` is the end pointer of the result from `std::to_chars`. /// `bufferEnd` is the end pointer of the buffer space given to `std::to_chars`. /// The extra buffer space is used to expand the result. /// `resultBegin`, `resultEnd`, and `bufferEnd` must point to the same buffer. /// /// The first char* of the return type is the begin pointer of the newly /// formatted output. The second char* of the return type is the begin pointer /// of the newly formatted output. std::pair<char*, char*> formatAsDoubleConversion( bool valueIsZero, DtoaMode mode, unsigned int numDigits, DtoaFlags flags, char* resultBegin, char* resultEnd, char* bufferEnd); template <class Tgt, class Src> typename std::enable_if< std::is_floating_point<Src>::value && IsSomeString<Tgt>::value>::type toAppendStdToChars( Src value, Tgt* result, DtoaMode mode, unsigned int numDigits, DtoaFlags flags = DtoaFlags::NO_FLAGS) { … } #endif // FOLLY_CONV_AVALIABILITY_TO_CHARS_FLOATING_POINT } // namespace detail /** * `numDigits` is only used with `FIXED` && `PRECISION`. */ template <class Tgt, class Src> typename std::enable_if< std::is_floating_point<Src>::value && IsSomeString<Tgt>::value>::type toAppend( Src value, Tgt* result, DtoaMode mode, unsigned int numDigits, DtoaFlags flags = DtoaFlags::NO_FLAGS) { … } /** * As above, but for floating point */ template <class Tgt, class Src> typename std::enable_if< std::is_floating_point<Src>::value && IsSomeString<Tgt>::value>::type toAppend(Src value, Tgt* result) { … } /** * 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) { … } template <class Src> constexpr typename std::enable_if< !std::is_fundamental<Src>::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<unsigned __int128, Src>::value && #endif !IsSomeString<Src>::value && !std::is_convertible<Src, const char*>::value && !std::is_convertible<Src, StringPiece>::value && !std::is_enum<Src>::value, size_t>::type estimateSpaceNeeded(const Src&) { … } #ifndef DOXYGEN_SHOULD_SKIP_THIS namespace detail { FOLLY_ERASE constexpr size_t estimateSpaceToReserveOne(std::false_type, void*) { … } template <typename T> FOLLY_ERASE constexpr size_t estimateSpaceToReserveOne( std::true_type, const T& v) { … } template <typename> struct EstimateSpaceToReserveAll; EstimateSpaceToReserveAll<std::index_sequence<I...>>; template <class O> void reserveInTarget(const O& o) { … } template <class T, class O> void reserveInTarget(const T& v, const O& o) { … } template <class T0, class T1, class... Ts> void reserveInTarget(const T0& v0, const T1& v1, const Ts&... vs) { … } template <class Delimiter, class... Ts> void reserveInTargetDelim(const Delimiter& d, const Ts&... vs) { … } template <class T> FOLLY_ERASE constexpr int toAppendStrImplOne( std::false_type, const T& v, void*) { … } template <class T, class Tgt> FOLLY_ERASE int toAppendStrImplOne(std::true_type, const T& v, Tgt result) { … } template <typename> struct ToAppendStrImplAll; ToAppendStrImplAll<std::index_sequence<I...>>; template <class Delimiter, class T> FOLLY_ERASE constexpr int toAppendDelimStrImplOne( index_constant<0>, const Delimiter& d, const T& v, void*) { … } template <class Delimiter, class T, class Tgt> FOLLY_ERASE int toAppendDelimStrImplOne( index_constant<1>, const Delimiter& d, const T& v, Tgt result) { … } template <class Delimiter, class T, class Tgt> FOLLY_ERASE int toAppendDelimStrImplOne( index_constant<2>, const Delimiter& d, const T& v, Tgt result) { … } template <typename> struct ToAppendDelimStrImplAll; ToAppendDelimStrImplAll<std::index_sequence<I...>>; template < class Delimiter, class T, class... Ts, std::enable_if_t< sizeof...(Ts) >= 2 && IsSomeString<typename std::remove_pointer< detail::LastElement<Ts...>>::type>::value, int> = 0> void toAppendDelimStrImpl(const Delimiter& delim, const T& v, const Ts&... vs) { … } } // namespace detail #endif /** * Variadic conversion to string. Appends each element in turn. * If we have two or more things to append, we 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 <class String> * void toAppend(const OtherType&, String* out); * * // optional * size_t estimateSpaceNeeded(const OtherType&); * * } */ template < class... Ts, std::enable_if_t< sizeof...(Ts) >= 3 && IsSomeString<typename std::remove_pointer< detail::LastElement<Ts...>>::type>::value, int> = 0> void toAppend(const Ts&... vs) { … } /** * @overloadbrief toAppend, but pre-allocate the exact amount of space required. * * Special version of the call that preallocates exactly 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, std::enable_if_t< IsSomeString<typename std::remove_pointer< detail::LastElement<Ts...>>::type>::value, int> = 0> void toAppendFit(const Ts&... vs) { … } template <class Ts> void toAppendFit(const Ts&) { … } /** * Variadic base case: do nothing. */ template <class Tgt> typename std::enable_if<IsSomeString<Tgt>::value>::type toAppend( Tgt* /* result */) { … } /** * @overloadbrief Use a specified delimiter between appendees. * * 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) { … } /** * Append to string with a delimiter in between elements. Check out * comments for toAppend for details about memory allocation. */ template < class Delimiter, class... Ts, std::enable_if_t< sizeof...(Ts) >= 3 && IsSomeString<typename std::remove_pointer< detail::LastElement<Ts...>>::type>::value, int> = 0> void toAppendDelim(const Delimiter& delim, const Ts&... vs) { … } /** * @overloadbrief toAppend with custom delimiter and exact pre-allocation. * * Detail in comment for toAppendFit */ template < class Delimiter, class... Ts, std::enable_if_t< IsSomeString<typename std::remove_pointer< detail::LastElement<Ts...>>::type>::value, int> = 0> void toAppendDelimFit(const Delimiter& delim, const Ts&... vs) { … } template <class De, class Ts> void toAppendDelimFit(const De&, const Ts&) { … } /** * to<SomeString>(v1, v2, ...) uses toAppend() (see below) as back-end * for all types. */ template < class Tgt, class... Ts, std::enable_if_t< IsSomeString<Tgt>::value && (sizeof...(Ts) != 1 || !std::is_same<Tgt, detail::LastElement<void, Ts...>>::value), int> = 0> Tgt to(const Ts&... vs) { … } /** * Special version of to<SomeString> for floating point. When calling * folly::to<SomeString>(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 <class Tgt, class Src> typename std::enable_if< IsSomeString<Tgt>::value && std::is_floating_point<Src>::value, Tgt>::type to(Src value) { … } /** * @overloadbrief Like `to`, but uses a custom delimiter. * * toDelim<SomeString>(SomeString str) returns itself. */ template <class Tgt, class Delim, class Src> typename std::enable_if< IsSomeString<Tgt>::value && std::is_same<Tgt, typename std::decay<Src>::type>::value, Tgt>::type toDelim(const Delim& /* delim */, Src&& value) { … } /** * toDelim<SomeString>(delim, v1, v2, ...) uses toAppendDelim() as * back-end for all types. */ template < class Tgt, class Delim, class... Ts, std::enable_if_t< IsSomeString<Tgt>::value && (sizeof...(Ts) != 1 || !std::is_same<Tgt, detail::LastElement<void, Ts...>>::value), int> = 0> Tgt toDelim(const Delim& delim, const Ts&... vs) { … } /** * Conversions from string types to integral types. */ namespace detail { Expected<bool, ConversionCode> str_to_bool(StringPiece* src) noexcept; template <typename T> Expected<T, ConversionCode> str_to_floating(StringPiece* src) noexcept; extern template Expected<float, ConversionCode> str_to_floating<float>( StringPiece* src) noexcept; extern template Expected<double, ConversionCode> str_to_floating<double>( StringPiece* src) noexcept; template <class Tgt> Expected<Tgt, ConversionCode> digits_to(const char* b, const char* e) noexcept; extern template Expected<char, ConversionCode> digits_to<char>( const char*, const char*) noexcept; extern template Expected<signed char, ConversionCode> digits_to<signed char>( const char*, const char*) noexcept; extern template Expected<unsigned char, ConversionCode> digits_to<unsigned char>(const char*, const char*) noexcept; extern template Expected<short, ConversionCode> digits_to<short>( const char*, const char*) noexcept; extern template Expected<unsigned short, ConversionCode> digits_to<unsigned short>(const char*, const char*) noexcept; extern template Expected<int, ConversionCode> digits_to<int>( const char*, const char*) noexcept; extern template Expected<unsigned int, ConversionCode> digits_to<unsigned int>( const char*, const char*) noexcept; extern template Expected<long, ConversionCode> digits_to<long>( const char*, const char*) noexcept; extern template Expected<unsigned long, ConversionCode> digits_to<unsigned long>(const char*, const char*) noexcept; extern template Expected<long long, ConversionCode> digits_to<long long>( const char*, const char*) noexcept; extern template Expected<unsigned long long, ConversionCode> digits_to<unsigned long long>(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<unsigned __int128, ConversionCode> digits_to<unsigned __int128>(const char*, const char*) noexcept; #endif template <class T> Expected<T, ConversionCode> str_to_integral(StringPiece* src) noexcept; extern template Expected<char, ConversionCode> str_to_integral<char>( StringPiece* src) noexcept; extern template Expected<signed char, ConversionCode> str_to_integral<signed char>(StringPiece* src) noexcept; extern template Expected<unsigned char, ConversionCode> str_to_integral<unsigned char>(StringPiece* src) noexcept; extern template Expected<short, ConversionCode> str_to_integral<short>( StringPiece* src) noexcept; extern template Expected<unsigned short, ConversionCode> str_to_integral<unsigned short>(StringPiece* src) noexcept; extern template Expected<int, ConversionCode> str_to_integral<int>( StringPiece* src) noexcept; extern template Expected<unsigned int, ConversionCode> str_to_integral<unsigned int>(StringPiece* src) noexcept; extern template Expected<long, ConversionCode> str_to_integral<long>( StringPiece* src) noexcept; extern template Expected<unsigned long, ConversionCode> str_to_integral<unsigned long>(StringPiece* src) noexcept; extern template Expected<long long, ConversionCode> str_to_integral<long long>( StringPiece* src) noexcept; extern template Expected<unsigned long long, ConversionCode> str_to_integral<unsigned long long>(StringPiece* src) noexcept; #if FOLLY_HAVE_INT128_T extern template Expected<__int128, ConversionCode> str_to_integral<__int128>( StringPiece* src) noexcept; extern template Expected<unsigned __int128, ConversionCode> str_to_integral<unsigned __int128>(StringPiece* src) noexcept; #endif template <typename T> typename std:: enable_if<std::is_same<T, bool>::value, Expected<T, ConversionCode>>::type convertTo(StringPiece* src) noexcept { … } template <typename T> typename std::enable_if< std::is_floating_point<T>::value, Expected<T, ConversionCode>>::type convertTo(StringPiece* src) noexcept { … } template <typename T> typename std::enable_if< is_integral_v<T> && !std::is_same<T, bool>::value, Expected<T, ConversionCode>>::type convertTo(StringPiece* src) noexcept { … } } // namespace detail /** * String represented as a pair of pointers to char to unsigned * integrals. Assumes NO whitespace before or after. */ template <typename Tgt> typename std::enable_if< is_integral_v<Tgt> && !std::is_same<Tgt, bool>::value, Expected<Tgt, ConversionCode>>::type tryTo(const char* b, const char* e) { … } template <typename Tgt> typename std::enable_if< // is_integral_v<Tgt> && !std::is_same<Tgt, bool>::value, Tgt>::type to(const char* b, const char* e) { … } /** * Conversions from string types to arithmetic types. */ /** * Parsing strings to numeric types. */ template <typename Tgt> FOLLY_NODISCARD inline typename std::enable_if< // is_arithmetic_v<Tgt>, Expected<StringPiece, ConversionCode>>::type parseTo(StringPiece src, Tgt& out) { … } /** * Integral / Floating Point to integral / Floating Point */ namespace detail { /** * Bool to integral/float doesn't need any special checks, and this * overload means we aren't trying to see if a bool is less than * an integer. */ template <class Tgt> typename std::enable_if< !std::is_same<Tgt, bool>::value && (is_integral_v<Tgt> || std::is_floating_point<Tgt>::value), Expected<Tgt, ConversionCode>>::type convertTo(const bool& value) noexcept { … } /** * Checked conversion from integral to integral. The checks are only * performed when meaningful, e.g. conversion from int to long goes * unchecked. */ template <class Tgt, class Src> typename std::enable_if< is_integral_v<Src> && !std::is_same<Tgt, Src>::value && !std::is_same<Tgt, bool>::value && is_integral_v<Tgt>, Expected<Tgt, ConversionCode>>::type convertTo(const Src& value) noexcept { … } /** * Checked conversion from floating to floating. The checks are only * performed when meaningful, e.g. conversion from float to double goes * unchecked. */ template <class Tgt, class Src> typename std::enable_if< std::is_floating_point<Tgt>::value && std::is_floating_point<Src>::value && !std::is_same<Tgt, Src>::value, Expected<Tgt, ConversionCode>>::type convertTo(const Src& value) noexcept { … } /** * Check if a floating point value can safely be converted to an * integer value without triggering undefined behaviour. */ template <typename Tgt, typename Src> inline typename std::enable_if< std::is_floating_point<Src>::value && is_integral_v<Tgt> && !std::is_same<Tgt, bool>::value, bool>::type checkConversion(const Src& value) { … } // Integers can always safely be converted to floating point values template <typename Tgt, typename Src> constexpr typename std::enable_if< is_integral_v<Src> && std::is_floating_point<Tgt>::value, bool>::type checkConversion(const Src&) { … } // 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 <typename Tgt, typename Src> constexpr typename std::enable_if< std::is_floating_point<Src>::value && std::is_same<Tgt, bool>::value, bool>::type checkConversion(const Src&) { … } /** * 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 <math>. */ template <typename Tgt, typename Src> typename std::enable_if< (is_integral_v<Src> && std::is_floating_point<Tgt>::value) || (std::is_floating_point<Src>::value && is_integral_v<Tgt>), Expected<Tgt, ConversionCode>>::type convertTo(const Src& value) noexcept { … } template <typename Tgt, typename Src> inline std::string errorValue(const Src& value) { … } IsArithToArith; } // namespace detail template <typename Tgt, typename Src> typename std::enable_if< detail::IsArithToArith<Tgt, Src>::value, Expected<Tgt, ConversionCode>>::type tryTo(const Src& value) noexcept { … } template <typename Tgt, typename Src> typename std::enable_if<detail::IsArithToArith<Tgt, Src>::value, Tgt>::type to( const Src& 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 <class T> FOLLY_NODISCARD typename std::enable_if< std::is_enum<T>::value, Expected<StringPiece, ConversionCode>>::type parseTo(StringPiece in, T& out) noexcept { … } FOLLY_NODISCARD inline Expected<StringPiece, ConversionCode> parseTo( StringPiece in, StringPiece& out) noexcept { … } namespace detail { template <class Str> FOLLY_ERASE Expected<StringPiece, ConversionCode> parseToStr( StringPiece in, Str& out) { … } } // namespace detail FOLLY_NODISCARD inline Expected<StringPiece, ConversionCode> parseTo( StringPiece in, std::string& out) { … } FOLLY_NODISCARD inline Expected<StringPiece, ConversionCode> parseTo( StringPiece in, std::string_view& out) { … } FOLLY_NODISCARD inline Expected<StringPiece, ConversionCode> parseTo( StringPiece in, fbstring& out) { … } template <class Str> FOLLY_NODISCARD inline typename std::enable_if< IsSomeString<Str>::value, Expected<StringPiece, ConversionCode>>::type parseTo(StringPiece in, Str& out) { … } namespace detail { ParseToResult; struct CheckTrailingSpace { … }; template <class Error> struct ReturnUnit { … }; // Older versions of the parseTo customization point threw on error and // returned void. Handle that. template <class Tgt> inline typename std::enable_if< std::is_void<ParseToResult<Tgt>>::value, Expected<StringPiece, ConversionCode>>::type parseToWrap(StringPiece sp, Tgt& out) { … } template <class Tgt> inline typename std::enable_if< !std::is_void<ParseToResult<Tgt>>::value, ParseToResult<Tgt>>::type parseToWrap(StringPiece sp, Tgt& out) { … } ParseToError; } // namespace detail /** * String or StringPiece to target conversion. Accepts leading and trailing * whitespace, but no non-space trailing characters. */ template <class Tgt> inline typename std::enable_if< !std::is_same<StringPiece, Tgt>::value, Expected<Tgt, detail::ParseToError<Tgt>>>::type tryTo(StringPiece src) { … } template <class Tgt, class Src> inline typename std::enable_if< IsSomeString<Src>::value && !std::is_same<StringPiece, Tgt>::value, Tgt>::type to(Src const& src) { … } template <class Tgt> inline typename std::enable_if<!std::is_same<StringPiece, Tgt>::value, Tgt>::type to(StringPiece src) { … } /** * 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 whitespace. */ template <class Tgt> Expected<Tgt, detail::ParseToError<Tgt>> tryTo(StringPiece* src) { … } template <class Tgt> Tgt to(StringPiece* src) { … } /** * Enum to anything and back */ template <class Tgt, class Src> typename std::enable_if< std::is_enum<Src>::value && !std::is_same<Src, Tgt>::value && !std::is_convertible<Tgt, StringPiece>::value, Expected<Tgt, ConversionCode>>::type tryTo(const Src& value) { … } template <class Tgt, class Src> typename std::enable_if< !std::is_convertible<Src, StringPiece>::value && std::is_enum<Tgt>::value && !std::is_same<Src, Tgt>::value, Expected<Tgt, ConversionCode>>::type tryTo(const Src& value) { … } template <class Tgt, class Src> typename std::enable_if< std::is_enum<Src>::value && !std::is_same<Src, Tgt>::value && !std::is_convertible<Tgt, StringPiece>::value, Tgt>::type to(const Src& value) { … } template <class Tgt, class Src> typename std::enable_if< !std::is_convertible<Src, StringPiece>::value && std::is_enum<Tgt>::value && !std::is_same<Src, Tgt>::value, Tgt>::type to(const Src& value) { … } } // namespace folly
Codebase Browser
folly