folly/Conv.h

   1 /*
   2  * Copyright 2016 Facebook, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *   http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /**
  18  * Converts anything to anything, with an emphasis on performance and
  19  * safety.
  20  *
  21  * @author Andrei Alexandrescu (andrei.alexandrescu@fb.com)
  22  */
  23
  24 #pragma once
  25
  26 #include <algorithm>
  27 #include <cctype>
  28 #include <climits>
  29 #include <cstddef>
  30 #include <limits>
  31 #include <stdexcept>
  32 #include <string>
  33 #include <tuple>
  34 #include <type_traits>
  35 #include <typeinfo>
  36 #include <utility>
  37
  38 #include <boost/implicit_cast.hpp>
  39 #include <double-conversion/double-conversion.h> // V8 JavaScript implementation
  40
  41 #include <folly/Demangle.h>
  42 #include <folly/FBString.h>
  43 #include <folly/Likely.h>
  44 #include <folly/Range.h>
  45 #include <folly/portability/Math.h>
  46
  47 namespace folly {
  48
  49 class ConversionError : public std::range_error {
  50  public:
  51   // Keep this in sync with kErrorStrings in Conv.cpp
  52   enum Code {
  53     SUCCESS,
  54     EMPTY_INPUT_STRING,
  55     NO_DIGITS,
  56     BOOL_OVERFLOW,
  57     BOOL_INVALID_VALUE,
  58     NON_DIGIT_CHAR,
  59     INVALID_LEADING_CHAR,
  60     POSITIVE_OVERFLOW,
  61     NEGATIVE_OVERFLOW,
  62     STRING_TO_FLOAT_ERROR,
  63     NON_WHITESPACE_AFTER_END,
  64     ARITH_POSITIVE_OVERFLOW,
  65     ARITH_NEGATIVE_OVERFLOW,
  66     ARITH_LOSS_OF_PRECISION,
  67     NUM_ERROR_CODES, // has to be the last entry
  68   };
  69
  70   ConversionError(const std::string& str, Code code)
  71       : std::range_error(str), code_(code) {}
  72
  73   ConversionError(const char* str, Code code)
  74       : std::range_error(str), code_(code) {}
  75
  76   Code errorCode() const { return code_; }
  77
  78  private:
  79   Code code_;
  80 };
  81
  82 namespace detail {
  83
  84 ConversionError makeConversionError(
  85     ConversionError::Code code,
  86     const char* input,
  87     size_t inputLen);
  88
  89 inline ConversionError makeConversionError(
  90     ConversionError::Code code,
  91     const std::string& str) {
  92   return makeConversionError(code, str.data(), str.size());
  93 }
  94
  95 inline ConversionError makeConversionError(
  96     ConversionError::Code code,
  97     StringPiece sp) {
  98   return makeConversionError(code, sp.data(), sp.size());
  99 }
 100
 101 /**
 102  * Enforce that the suffix following a number is made up only of whitespace.
 103  */
 104 inline ConversionError::Code enforceWhitespaceErr(StringPiece sp) {
 105   for (auto c : sp) {
 106     if (!std::isspace(c)) {
 107       return ConversionError::NON_WHITESPACE_AFTER_END;
 108     }
 109   }
 110   return ConversionError::SUCCESS;
 111 }
 112
 113 /**
 114  * Keep this implementation around for prettyToDouble().
 115  */
 116 inline void enforceWhitespace(StringPiece sp) {
 117   auto err = enforceWhitespaceErr(sp);
 118   if (err != ConversionError::SUCCESS) {
 119     throw detail::makeConversionError(err, sp);
 120   }
 121 }
 122
 123 /**
 124  * A simple std::pair-like wrapper to wrap both a value and an error
 125  */
 126 template <typename T>
 127 struct ConversionResult {
 128   explicit ConversionResult(T v) : value(v) {}
 129   explicit ConversionResult(ConversionError::Code e) : error(e) {}
 130
 131   bool success() const {
 132     return error == ConversionError::SUCCESS;
 133   }
 134
 135   T value;
 136   ConversionError::Code error{ConversionError::SUCCESS};
 137 };
 138 }
 139
 140 /**
 141  * The identity conversion function.
 142  * to<T>(T) returns itself for all types T.
 143  */
 144 template <class Tgt, class Src>
 145 typename std::enable_if<std::is_same<Tgt, Src>::value, Tgt>::type
 146 to(const Src & value) {
 147   return value;
 148 }
 149
 150 template <class Tgt, class Src>
 151 typename std::enable_if<std::is_same<Tgt, Src>::value, Tgt>::type
 152 to(Src && value) {
 153   return std::forward<Src>(value);
 154 }
 155
 156 /*******************************************************************************
 157  * Anything to string
 158  ******************************************************************************/
 159
 160 namespace detail {
 161
 162 template <class T>
 163 const T& getLastElement(const T & v) {
 164   return v;
 165 }
 166
 167 template <class T, class... Ts>
 168 typename std::tuple_element<
 169   sizeof...(Ts),
 170   std::tuple<T, Ts...> >::type const&
 171   getLastElement(const T&, const Ts&... vs) {
 172   return getLastElement(vs...);
 173 }
 174
 175 // This class exists to specialize away std::tuple_element in the case where we
 176 // have 0 template arguments. Without this, Clang/libc++ will blow a
 177 // static_assert even if tuple_element is protected by an enable_if.
 178 template <class... Ts>
 179 struct last_element {
 180   typedef typename std::enable_if<
 181     sizeof...(Ts) >= 1,
 182     typename std::tuple_element<
 183       sizeof...(Ts) - 1, std::tuple<Ts...>
 184     >::type>::type type;
 185 };
 186
 187 template <>
 188 struct last_element<> {
 189   typedef void type;
 190 };
 191
 192 } // namespace detail
 193
 194 /*******************************************************************************
 195  * Conversions from integral types to string types.
 196  ******************************************************************************/
 197
 198 #if FOLLY_HAVE_INT128_T
 199 namespace detail {
 200
 201 template <typename IntegerType>
 202 constexpr unsigned int
 203 digitsEnough() {
 204   return (unsigned int)(ceil(sizeof(IntegerType) * CHAR_BIT * M_LN2 / M_LN10));
 205 }
 206
 207 inline size_t
 208 unsafeTelescope128(char * buffer, size_t room, unsigned __int128 x) {
 209   typedef unsigned __int128 Usrc;
 210   size_t p = room - 1;
 211
 212   while (x >= (Usrc(1) << 64)) { // Using 128-bit division while needed
 213     const auto y = x / 10;
 214     const auto digit = x % 10;
 215
 216     buffer[p--] = '0' + digit;
 217     x = y;
 218   }
 219
 220   uint64_t xx = x; // Moving to faster 64-bit division thereafter
 221
 222   while (xx >= 10) {
 223     const auto y = xx / 10ULL;
 224     const auto digit = xx % 10ULL;
 225
 226     buffer[p--] = '0' + digit;
 227     xx = y;
 228   }
 229
 230   buffer[p] = '0' + xx;
 231
 232   return p;
 233 }
 234
 235 }
 236 #endif
 237
 238 /**
 239  * Returns the number of digits in the base 10 representation of an
 240  * uint64_t. Useful for preallocating buffers and such. It's also used
 241  * internally, see below. Measurements suggest that defining a
 242  * separate overload for 32-bit integers is not worthwhile.
 243  */
 244
 245 inline uint32_t digits10(uint64_t v) {
 246 #ifdef __x86_64__
 247
 248   // For this arch we can get a little help from specialized CPU instructions
 249   // which can count leading zeroes; 64 minus that is appx. log (base 2).
 250   // Use that to approximate base-10 digits (log_10) and then adjust if needed.
 251
 252   // 10^i, defined for i 0 through 19.
 253   // This is 20 * 8 == 160 bytes, which fits neatly into 5 cache lines
 254   // (assuming a cache line size of 64).
 255   static const uint64_t powersOf10[20] FOLLY_ALIGNED(64) = {
 256       1,
 257       10,
 258       100,
 259       1000,
 260       10000,
 261       100000,
 262       1000000,
 263       10000000,
 264       100000000,
 265       1000000000,
 266       10000000000,
 267       100000000000,
 268       1000000000000,
 269       10000000000000,
 270       100000000000000,
 271       1000000000000000,
 272       10000000000000000,
 273       100000000000000000,
 274       1000000000000000000,
 275       10000000000000000000UL,
 276   };
 277
 278   // "count leading zeroes" operation not valid; for 0; special case this.
 279   if UNLIKELY (! v) {
 280     return 1;
 281   }
 282
 283   // bits is in the ballpark of log_2(v).
 284   const uint8_t leadingZeroes = __builtin_clzll(v);
 285   const auto bits = 63 - leadingZeroes;
 286
 287   // approximate log_10(v) == log_10(2) * bits.
 288   // Integer magic below: 77/256 is appx. 0.3010 (log_10(2)).
 289   // The +1 is to make this the ceiling of the log_10 estimate.
 290   const uint32_t minLength = 1 + ((bits * 77) >> 8);
 291
 292   // return that log_10 lower bound, plus adjust if input >= 10^(that bound)
 293   // in case there's a small error and we misjudged length.
 294   return minLength + (uint32_t) (UNLIKELY (v >= powersOf10[minLength]));
 295
 296 #else
 297
 298   uint32_t result = 1;
 299   for (;;) {
 300     if (LIKELY(v < 10)) return result;
 301     if (LIKELY(v < 100)) return result + 1;
 302     if (LIKELY(v < 1000)) return result + 2;
 303     if (LIKELY(v < 10000)) return result + 3;
 304     // Skip ahead by 4 orders of magnitude
 305     v /= 10000U;
 306     result += 4;
 307   }
 308
 309 #endif
 310 }
 311
 312 /**
 313  * Copies the ASCII base 10 representation of v into buffer and
 314  * returns the number of bytes written. Does NOT append a \0. Assumes
 315  * the buffer points to digits10(v) bytes of valid memory. Note that
 316  * uint64 needs at most 20 bytes, uint32_t needs at most 10 bytes,
 317  * uint16_t needs at most 5 bytes, and so on. Measurements suggest
 318  * that defining a separate overload for 32-bit integers is not
 319  * worthwhile.
 320  *
 321  * This primitive is unsafe because it makes the size assumption and
 322  * because it does not add a terminating \0.
 323  */
 324
 325 inline uint32_t uint64ToBufferUnsafe(uint64_t v, char *const buffer) {
 326   auto const result = digits10(v);
 327   // WARNING: using size_t or pointer arithmetic for pos slows down
 328   // the loop below 20x. This is because several 32-bit ops can be
 329   // done in parallel, but only fewer 64-bit ones.
 330   uint32_t pos = result - 1;
 331   while (v >= 10) {
 332     // Keep these together so a peephole optimization "sees" them and
 333     // computes them in one shot.
 334     auto const q = v / 10;
 335     auto const r = static_cast<uint32_t>(v % 10);
 336     buffer[pos--] = '0' + r;
 337     v = q;
 338   }
 339   // Last digit is trivial to handle
 340   buffer[pos] = static_cast<uint32_t>(v) + '0';
 341   return result;
 342 }
 343
 344 /**
 345  * A single char gets appended.
 346  */
 347 template <class Tgt>
 348 void toAppend(char value, Tgt * result) {
 349   *result += value;
 350 }
 351
 352 template<class T>
 353 constexpr typename std::enable_if<
 354   std::is_same<T, char>::value,
 355   size_t>::type
 356 estimateSpaceNeeded(T) {
 357   return 1;
 358 }
 359
 360 /**
 361  * Everything implicitly convertible to const char* gets appended.
 362  */
 363 template <class Tgt, class Src>
 364 typename std::enable_if<
 365   std::is_convertible<Src, const char*>::value
 366   && IsSomeString<Tgt>::value>::type
 367 toAppend(Src value, Tgt * result) {
 368   // Treat null pointers like an empty string, as in:
 369   // operator<<(std::ostream&, const char*).
 370   const char* c = value;
 371   if (c) {
 372     result->append(value);
 373   }
 374 }
 375
 376 template<class Src>
 377 typename std::enable_if<
 378   std::is_convertible<Src, const char*>::value,
 379   size_t>::type
 380 estimateSpaceNeeded(Src value) {
 381   const char *c = value;
 382   if (c) {
 383     return folly::StringPiece(value).size();
 384   };
 385   return 0;
 386 }
 387
 388 template<class Src>
 389 typename std::enable_if<
 390   (std::is_convertible<Src, folly::StringPiece>::value ||
 391   IsSomeString<Src>::value) &&
 392   !std::is_convertible<Src, const char*>::value,
 393   size_t>::type
 394 estimateSpaceNeeded(Src value) {
 395   return folly::StringPiece(value).size();
 396 }
 397
 398 template <>
 399 inline size_t estimateSpaceNeeded(std::nullptr_t /* value */) {
 400   return 0;
 401 }
 402
 403 template<class Src>
 404 typename std::enable_if<
 405   std::is_pointer<Src>::value &&
 406   IsSomeString<std::remove_pointer<Src>>::value,
 407   size_t>::type
 408 estimateSpaceNeeded(Src value) {
 409   return value->size();
 410 }
 411
 412 /**
 413  * Strings get appended, too.
 414  */
 415 template <class Tgt, class Src>
 416 typename std::enable_if<
 417   IsSomeString<Src>::value && IsSomeString<Tgt>::value>::type
 418 toAppend(const Src& value, Tgt * result) {
 419   result->append(value);
 420 }
 421
 422 /**
 423  * and StringPiece objects too
 424  */
 425 template <class Tgt>
 426 typename std::enable_if<
 427    IsSomeString<Tgt>::value>::type
 428 toAppend(StringPiece value, Tgt * result) {
 429   result->append(value.data(), value.size());
 430 }
 431
 432 /**
 433  * There's no implicit conversion from fbstring to other string types,
 434  * so make a specialization.
 435  */
 436 template <class Tgt>
 437 typename std::enable_if<
 438    IsSomeString<Tgt>::value>::type
 439 toAppend(const fbstring& value, Tgt * result) {
 440   result->append(value.data(), value.size());
 441 }
 442
 443 #if FOLLY_HAVE_INT128_T
 444 /**
 445  * Special handling for 128 bit integers.
 446  */
 447
 448 template <class Tgt>
 449 void
 450 toAppend(__int128 value, Tgt * result) {
 451   typedef unsigned __int128 Usrc;
 452   char buffer[detail::digitsEnough<unsigned __int128>() + 1];
 453   size_t p;
 454
 455   if (value < 0) {
 456     p = detail::unsafeTelescope128(buffer, sizeof(buffer), -Usrc(value));
 457     buffer[--p] = '-';
 458   } else {
 459     p = detail::unsafeTelescope128(buffer, sizeof(buffer), value);
 460   }
 461
 462   result->append(buffer + p, buffer + sizeof(buffer));
 463 }
 464
 465 template <class Tgt>
 466 void
 467 toAppend(unsigned __int128 value, Tgt * result) {
 468   char buffer[detail::digitsEnough<unsigned __int128>()];
 469   size_t p;
 470
 471   p = detail::unsafeTelescope128(buffer, sizeof(buffer), value);
 472
 473   result->append(buffer + p, buffer + sizeof(buffer));
 474 }
 475
 476 template<class T>
 477 constexpr typename std::enable_if<
 478   std::is_same<T, __int128>::value,
 479   size_t>::type
 480 estimateSpaceNeeded(T) {
 481   return detail::digitsEnough<__int128>();
 482 }
 483
 484 template<class T>
 485 constexpr typename std::enable_if<
 486   std::is_same<T, unsigned __int128>::value,
 487   size_t>::type
 488 estimateSpaceNeeded(T) {
 489   return detail::digitsEnough<unsigned __int128>();
 490 }
 491
 492 #endif
 493
 494 /**
 495  * int32_t and int64_t to string (by appending) go through here. The
 496  * result is APPENDED to a preexisting string passed as the second
 497  * parameter. This should be efficient with fbstring because fbstring
 498  * incurs no dynamic allocation below 23 bytes and no number has more
 499  * than 22 bytes in its textual representation (20 for digits, one for
 500  * sign, one for the terminating 0).
 501  */
 502 template <class Tgt, class Src>
 503 typename std::enable_if<
 504   std::is_integral<Src>::value && std::is_signed<Src>::value &&
 505   IsSomeString<Tgt>::value && sizeof(Src) >= 4>::type
 506 toAppend(Src value, Tgt * result) {
 507   char buffer[20];
 508   if (value < 0) {
 509     result->push_back('-');
 510     result->append(buffer, uint64ToBufferUnsafe(-uint64_t(value), buffer));
 511   } else {
 512     result->append(buffer, uint64ToBufferUnsafe(value, buffer));
 513   }
 514 }
 515
 516 template <class Src>
 517 typename std::enable_if<
 518   std::is_integral<Src>::value && std::is_signed<Src>::value
 519   && sizeof(Src) >= 4 && sizeof(Src) < 16,
 520   size_t>::type
 521 estimateSpaceNeeded(Src value) {
 522   if (value < 0) {
 523     // When "value" is the smallest negative, negating it would evoke
 524     // undefined behavior, so, instead of writing "-value" below, we write
 525     // "~static_cast<uint64_t>(value) + 1"
 526     return 1 + digits10(~static_cast<uint64_t>(value) + 1);
 527   }
 528
 529   return digits10(static_cast<uint64_t>(value));
 530 }
 531
 532 /**
 533  * As above, but for uint32_t and uint64_t.
 534  */
 535 template <class Tgt, class Src>
 536 typename std::enable_if<
 537   std::is_integral<Src>::value && !std::is_signed<Src>::value
 538   && IsSomeString<Tgt>::value && sizeof(Src) >= 4>::type
 539 toAppend(Src value, Tgt * result) {
 540   char buffer[20];
 541   result->append(buffer, uint64ToBufferUnsafe(value, buffer));
 542 }
 543
 544 template <class Src>
 545 typename std::enable_if<
 546   std::is_integral<Src>::value && !std::is_signed<Src>::value
 547   && sizeof(Src) >= 4 && sizeof(Src) < 16,
 548   size_t>::type
 549 estimateSpaceNeeded(Src value) {
 550   return digits10(value);
 551 }
 552
 553 /**
 554  * All small signed and unsigned integers to string go through 32-bit
 555  * types int32_t and uint32_t, respectively.
 556  */
 557 template <class Tgt, class Src>
 558 typename std::enable_if<
 559   std::is_integral<Src>::value
 560   && IsSomeString<Tgt>::value && sizeof(Src) < 4>::type
 561 toAppend(Src value, Tgt * result) {
 562   typedef typename
 563     std::conditional<std::is_signed<Src>::value, int64_t, uint64_t>::type
 564     Intermediate;
 565   toAppend<Tgt>(static_cast<Intermediate>(value), result);
 566 }
 567
 568 template <class Src>
 569 typename std::enable_if<
 570   std::is_integral<Src>::value
 571   && sizeof(Src) < 4
 572   && !std::is_same<Src, char>::value,
 573   size_t>::type
 574 estimateSpaceNeeded(Src value) {
 575   typedef typename
 576     std::conditional<std::is_signed<Src>::value, int64_t, uint64_t>::type
 577     Intermediate;
 578   return estimateSpaceNeeded(static_cast<Intermediate>(value));
 579 }
 580
 581 /**
 582  * Enumerated values get appended as integers.
 583  */
 584 template <class Tgt, class Src>
 585 typename std::enable_if<
 586   std::is_enum<Src>::value && IsSomeString<Tgt>::value>::type
 587 toAppend(Src value, Tgt * result) {
 588   toAppend(
 589       static_cast<typename std::underlying_type<Src>::type>(value), result);
 590 }
 591
 592 template <class Src>
 593 typename std::enable_if<
 594   std::is_enum<Src>::value, size_t>::type
 595 estimateSpaceNeeded(Src value) {
 596   return estimateSpaceNeeded(
 597       static_cast<typename std::underlying_type<Src>::type>(value));
 598 }
 599
 600 /*******************************************************************************
 601  * Conversions from floating-point types to string types.
 602  ******************************************************************************/
 603
 604 namespace detail {
 605 constexpr int kConvMaxDecimalInShortestLow = -6;
 606 constexpr int kConvMaxDecimalInShortestHigh = 21;
 607 } // folly::detail
 608
 609 /** Wrapper around DoubleToStringConverter **/
 610 template <class Tgt, class Src>
 611 typename std::enable_if<
 612   std::is_floating_point<Src>::value
 613   && IsSomeString<Tgt>::value>::type
 614 toAppend(
 615   Src value,
 616   Tgt * result,
 617   double_conversion::DoubleToStringConverter::DtoaMode mode,
 618   unsigned int numDigits) {
 619   using namespace double_conversion;
 620   DoubleToStringConverter
 621     conv(DoubleToStringConverter::NO_FLAGS,
 622          "Infinity", "NaN", 'E',
 623          detail::kConvMaxDecimalInShortestLow,
 624          detail::kConvMaxDecimalInShortestHigh,
 625          6,   // max leading padding zeros
 626          1);  // max trailing padding zeros
 627   char buffer[256];
 628   StringBuilder builder(buffer, sizeof(buffer));
 629   switch (mode) {
 630     case DoubleToStringConverter::SHORTEST:
 631       conv.ToShortest(value, &builder);
 632       break;
 633     case DoubleToStringConverter::FIXED:
 634       conv.ToFixed(value, numDigits, &builder);
 635       break;
 636     default:
 637       CHECK(mode == DoubleToStringConverter::PRECISION);
 638       conv.ToPrecision(value, numDigits, &builder);
 639       break;
 640   }
 641   const size_t length = builder.position();
 642   builder.Finalize();
 643   result->append(buffer, length);
 644 }
 645
 646 /**
 647  * As above, but for floating point
 648  */
 649 template <class Tgt, class Src>
 650 typename std::enable_if<
 651   std::is_floating_point<Src>::value
 652   && IsSomeString<Tgt>::value>::type
 653 toAppend(Src value, Tgt * result) {
 654   toAppend(
 655     value, result, double_conversion::DoubleToStringConverter::SHORTEST, 0);
 656 }
 657
 658 /**
 659  * Upper bound of the length of the output from
 660  * DoubleToStringConverter::ToShortest(double, StringBuilder*),
 661  * as used in toAppend(double, string*).
 662  */
 663 template <class Src>
 664 typename std::enable_if<
 665   std::is_floating_point<Src>::value, size_t>::type
 666 estimateSpaceNeeded(Src value) {
 667   // kBase10MaximalLength is 17. We add 1 for decimal point,
 668   // e.g. 10.0/9 is 17 digits and 18 characters, including the decimal point.
 669   constexpr int kMaxMantissaSpace =
 670     double_conversion::DoubleToStringConverter::kBase10MaximalLength + 1;
 671   // strlen("E-") + digits10(numeric_limits<double>::max_exponent10)
 672   constexpr int kMaxExponentSpace = 2 + 3;
 673   static const int kMaxPositiveSpace = std::max({
 674       // E.g. 1.1111111111111111E-100.
 675       kMaxMantissaSpace + kMaxExponentSpace,
 676       // E.g. 0.000001.1111111111111111, if kConvMaxDecimalInShortestLow is -6.
 677       kMaxMantissaSpace - detail::kConvMaxDecimalInShortestLow,
 678       // If kConvMaxDecimalInShortestHigh is 21, then 1e21 is the smallest
 679       // number > 1 which ToShortest outputs in exponential notation,
 680       // so 21 is the longest non-exponential number > 1.
 681       detail::kConvMaxDecimalInShortestHigh
 682     });
 683   return kMaxPositiveSpace + (value < 0);  // +1 for minus sign, if negative
 684 }
 685
 686 /**
 687  * This can be specialized, together with adding specialization
 688  * for estimateSpaceNeed for your type, so that we allocate
 689  * as much as you need instead of the default
 690  */
 691 template<class Src>
 692 struct HasLengthEstimator : std::false_type {};
 693
 694 template <class Src>
 695 constexpr typename std::enable_if<
 696   !std::is_fundamental<Src>::value
 697 #if FOLLY_HAVE_INT128_T
 698   // On OSX 10.10, is_fundamental<__int128> is false :-O
 699   && !std::is_same<__int128, Src>::value
 700   && !std::is_same<unsigned __int128, Src>::value
 701 #endif
 702   && !IsSomeString<Src>::value
 703   && !std::is_convertible<Src, const char*>::value
 704   && !std::is_convertible<Src, StringPiece>::value
 705   && !std::is_enum<Src>::value
 706   && !HasLengthEstimator<Src>::value,
 707   size_t>::type
 708 estimateSpaceNeeded(const Src&) {
 709   return sizeof(Src) + 1; // dumbest best effort ever?
 710 }
 711
 712 namespace detail {
 713
 714 template <class Tgt>
 715 typename std::enable_if<IsSomeString<Tgt>::value, size_t>::type
 716 estimateSpaceToReserve(size_t sofar, Tgt*) {
 717   return sofar;
 718 }
 719
 720 template <class T, class... Ts>
 721 size_t estimateSpaceToReserve(size_t sofar, const T& v, const Ts&... vs) {
 722   return estimateSpaceToReserve(sofar + estimateSpaceNeeded(v), vs...);
 723 }
 724
 725 template<class...Ts>
 726 void reserveInTarget(const Ts&...vs) {
 727   getLastElement(vs...)->reserve(estimateSpaceToReserve(0, vs...));
 728 }
 729
 730 template<class Delimiter, class...Ts>
 731 void reserveInTargetDelim(const Delimiter& d, const Ts&...vs) {
 732   static_assert(sizeof...(vs) >= 2, "Needs at least 2 args");
 733   size_t fordelim = (sizeof...(vs) - 2) *
 734       estimateSpaceToReserve(0, d, static_cast<std::string*>(nullptr));
 735   getLastElement(vs...)->reserve(estimateSpaceToReserve(fordelim, vs...));
 736 }
 737
 738 /**
 739  * Variadic base case: append one element
 740  */
 741 template <class T, class Tgt>
 742 typename std::enable_if<
 743   IsSomeString<typename std::remove_pointer<Tgt>::type>
 744   ::value>::type
 745 toAppendStrImpl(const T& v, Tgt result) {
 746   toAppend(v, result);
 747 }
 748
 749 template <class T, class... Ts>
 750 typename std::enable_if<sizeof...(Ts) >= 2
 751   && IsSomeString<
 752   typename std::remove_pointer<
 753     typename detail::last_element<Ts...>::type
 754   >::type>::value>::type
 755 toAppendStrImpl(const T& v, const Ts&... vs) {
 756   toAppend(v, getLastElement(vs...));
 757   toAppendStrImpl(vs...);
 758 }
 759
 760 template <class Delimiter, class T, class Tgt>
 761 typename std::enable_if<
 762     IsSomeString<typename std::remove_pointer<Tgt>::type>::value>::type
 763 toAppendDelimStrImpl(const Delimiter& /* delim */, const T& v, Tgt result) {
 764   toAppend(v, result);
 765 }
 766
 767 template <class Delimiter, class T, class... Ts>
 768 typename std::enable_if<sizeof...(Ts) >= 2
 769   && IsSomeString<
 770   typename std::remove_pointer<
 771     typename detail::last_element<Ts...>::type
 772   >::type>::value>::type
 773 toAppendDelimStrImpl(const Delimiter& delim, const T& v, const Ts&... vs) {
 774   // we are really careful here, calling toAppend with just one element does
 775   // not try to estimate space needed (as we already did that). If we call
 776   // toAppend(v, delim, ....) we would do unnecesary size calculation
 777   toAppend(v, detail::getLastElement(vs...));
 778   toAppend(delim, detail::getLastElement(vs...));
 779   toAppendDelimStrImpl(delim, vs...);
 780 }
 781 } // folly::detail
 782
 783
 784 /**
 785  * Variadic conversion to string. Appends each element in turn.
 786  * If we have two or more things to append, we it will not reserve
 787  * the space for them and will depend on strings exponential growth.
 788  * If you just append once consider using toAppendFit which reserves
 789  * the space needed (but does not have exponential as a result).
 790  *
 791  * Custom implementations of toAppend() can be provided in the same namespace as
 792  * the type to customize printing. estimateSpaceNeed() may also be provided to
 793  * avoid reallocations in toAppendFit():
 794  *
 795  * namespace other_namespace {
 796  *
 797  * template <class String>
 798  * void toAppend(const OtherType&, String* out);
 799  *
 800  * // optional
 801  * size_t estimateSpaceNeeded(const OtherType&);
 802  *
 803  * }
 804  */
 805 template <class... Ts>
 806 typename std::enable_if<sizeof...(Ts) >= 3
 807   && IsSomeString<
 808   typename std::remove_pointer<
 809     typename detail::last_element<Ts...>::type
 810   >::type>::value>::type
 811 toAppend(const Ts&... vs) {
 812   ::folly::detail::toAppendStrImpl(vs...);
 813 }
 814
 815 #ifdef _MSC_VER
 816 // Special case pid_t on MSVC, because it's a void* rather than an
 817 // integral type. We can't do a global special case because this is already
 818 // dangerous enough (as most pointers will implicitly convert to a void*)
 819 // just doing it for MSVC.
 820 template <class Tgt>
 821 void toAppend(const pid_t a, Tgt* res) {
 822   toAppend(uint64_t(a), res);
 823 }
 824 #endif
 825
 826 /**
 827  * Special version of the call that preallocates exaclty as much memory
 828  * as need for arguments to be stored in target. This means we are
 829  * not doing exponential growth when we append. If you are using it
 830  * in a loop you are aiming at your foot with a big perf-destroying
 831  * bazooka.
 832  * On the other hand if you are appending to a string once, this
 833  * will probably save a few calls to malloc.
 834  */
 835 template <class... Ts>
 836 typename std::enable_if<
 837   IsSomeString<
 838   typename std::remove_pointer<
 839     typename detail::last_element<Ts...>::type
 840   >::type>::value>::type
 841 toAppendFit(const Ts&... vs) {
 842   ::folly::detail::reserveInTarget(vs...);
 843   toAppend(vs...);
 844 }
 845
 846 template <class Ts>
 847 void toAppendFit(const Ts&) {}
 848
 849 /**
 850  * Variadic base case: do nothing.
 851  */
 852 template <class Tgt>
 853 typename std::enable_if<IsSomeString<Tgt>::value>::type toAppend(
 854     Tgt* /* result */) {}
 855
 856 /**
 857  * Variadic base case: do nothing.
 858  */
 859 template <class Delimiter, class Tgt>
 860 typename std::enable_if<IsSomeString<Tgt>::value>::type toAppendDelim(
 861     const Delimiter& /* delim */, Tgt* /* result */) {}
 862
 863 /**
 864  * 1 element: same as toAppend.
 865  */
 866 template <class Delimiter, class T, class Tgt>
 867 typename std::enable_if<IsSomeString<Tgt>::value>::type toAppendDelim(
 868     const Delimiter& /* delim */, const T& v, Tgt* tgt) {
 869   toAppend(v, tgt);
 870 }
 871
 872 /**
 873  * Append to string with a delimiter in between elements. Check out
 874  * comments for toAppend for details about memory allocation.
 875  */
 876 template <class Delimiter, class... Ts>
 877 typename std::enable_if<sizeof...(Ts) >= 3
 878   && IsSomeString<
 879   typename std::remove_pointer<
 880     typename detail::last_element<Ts...>::type
 881   >::type>::value>::type
 882 toAppendDelim(const Delimiter& delim, const Ts&... vs) {
 883   detail::toAppendDelimStrImpl(delim, vs...);
 884 }
 885
 886 /**
 887  * Detail in comment for toAppendFit
 888  */
 889 template <class Delimiter, class... Ts>
 890 typename std::enable_if<
 891   IsSomeString<
 892   typename std::remove_pointer<
 893     typename detail::last_element<Ts...>::type
 894   >::type>::value>::type
 895 toAppendDelimFit(const Delimiter& delim, const Ts&... vs) {
 896   detail::reserveInTargetDelim(delim, vs...);
 897   toAppendDelim(delim, vs...);
 898 }
 899
 900 template <class De, class Ts>
 901 void toAppendDelimFit(const De&, const Ts&) {}
 902
 903 /**
 904  * to<SomeString>(v1, v2, ...) uses toAppend() (see below) as back-end
 905  * for all types.
 906  */
 907 template <class Tgt, class... Ts>
 908 typename std::enable_if<
 909   IsSomeString<Tgt>::value && (
 910     sizeof...(Ts) != 1 ||
 911     !std::is_same<Tgt, typename detail::last_element<Ts...>::type>::value),
 912   Tgt>::type
 913 to(const Ts&... vs) {
 914   Tgt result;
 915   toAppendFit(vs..., &result);
 916   return result;
 917 }
 918
 919 /**
 920  * toDelim<SomeString>(SomeString str) returns itself.
 921  */
 922 template <class Tgt, class Delim, class Src>
 923 typename std::enable_if<IsSomeString<Tgt>::value &&
 924                             std::is_same<Tgt, Src>::value,
 925                         Tgt>::type
 926 toDelim(const Delim& /* delim */, const Src& value) {
 927   return value;
 928 }
 929
 930 /**
 931  * toDelim<SomeString>(delim, v1, v2, ...) uses toAppendDelim() as
 932  * back-end for all types.
 933  */
 934 template <class Tgt, class Delim, class... Ts>
 935 typename std::enable_if<
 936   IsSomeString<Tgt>::value && (
 937     sizeof...(Ts) != 1 ||
 938     !std::is_same<Tgt, typename detail::last_element<Ts...>::type>::value),
 939   Tgt>::type
 940 toDelim(const Delim& delim, const Ts&... vs) {
 941   Tgt result;
 942   toAppendDelimFit(delim, vs..., &result);
 943   return result;
 944 }
 945
 946 /*******************************************************************************
 947  * Conversions from string types to integral types.
 948  ******************************************************************************/
 949
 950 namespace detail {
 951
 952 ConversionResult<bool> str_to_bool(StringPiece* src);
 953
 954 template <typename T>
 955 ConversionResult<T> str_to_floating(StringPiece* src);
 956
 957 extern template ConversionResult<float> str_to_floating<float>(
 958     StringPiece* src);
 959 extern template ConversionResult<double> str_to_floating<double>(
 960     StringPiece* src);
 961
 962 template <class Tgt>
 963 ConversionResult<Tgt> digits_to(const char* b, const char* e);
 964
 965 extern template ConversionResult<char> digits_to<char>(
 966     const char*,
 967     const char*);
 968 extern template ConversionResult<signed char> digits_to<signed char>(
 969     const char*,
 970     const char*);
 971 extern template ConversionResult<unsigned char> digits_to<unsigned char>(
 972     const char*,
 973     const char*);
 974
 975 extern template ConversionResult<short> digits_to<short>(
 976     const char*,
 977     const char*);
 978 extern template ConversionResult<unsigned short> digits_to<unsigned short>(
 979     const char*,
 980     const char*);
 981
 982 extern template ConversionResult<int> digits_to<int>(const char*, const char*);
 983 extern template ConversionResult<unsigned int> digits_to<unsigned int>(
 984     const char*,
 985     const char*);
 986
 987 extern template ConversionResult<long> digits_to<long>(
 988     const char*,
 989     const char*);
 990 extern template ConversionResult<unsigned long> digits_to<unsigned long>(
 991     const char*,
 992     const char*);
 993
 994 extern template ConversionResult<long long> digits_to<long long>(
 995     const char*,
 996     const char*);
 997 extern template ConversionResult<unsigned long long>
 998 digits_to<unsigned long long>(const char*, const char*);
 999
1000 #if FOLLY_HAVE_INT128_T
1001 extern template ConversionResult<__int128> digits_to<__int128>(
1002     const char*,
1003     const char*);
1004 extern template ConversionResult<unsigned __int128>
1005 digits_to<unsigned __int128>(const char*, const char*);
1006 #endif
1007
1008 template <class T>
1009 ConversionResult<T> str_to_integral(StringPiece* src);
1010
1011 extern template ConversionResult<char> str_to_integral<char>(StringPiece* src);
1012 extern template ConversionResult<signed char> str_to_integral<signed char>(
1013     StringPiece* src);
1014 extern template ConversionResult<unsigned char> str_to_integral<unsigned char>(
1015     StringPiece* src);
1016
1017 extern template ConversionResult<short> str_to_integral<short>(
1018     StringPiece* src);
1019 extern template ConversionResult<unsigned short>
1020 str_to_integral<unsigned short>(StringPiece* src);
1021
1022 extern template ConversionResult<int> str_to_integral<int>(StringPiece* src);
1023 extern template ConversionResult<unsigned int> str_to_integral<unsigned int>(
1024     StringPiece* src);
1025
1026 extern template ConversionResult<long> str_to_integral<long>(StringPiece* src);
1027 extern template ConversionResult<unsigned long> str_to_integral<unsigned long>(
1028     StringPiece* src);
1029
1030 extern template ConversionResult<long long> str_to_integral<long long>(
1031     StringPiece* src);
1032 extern template ConversionResult<unsigned long long>
1033 str_to_integral<unsigned long long>(StringPiece* src);
1034
1035 #if FOLLY_HAVE_INT128_T
1036 extern template ConversionResult<__int128> str_to_integral<__int128>(
1037     StringPiece* src);
1038 extern template ConversionResult<unsigned __int128>
1039 str_to_integral<unsigned __int128>(StringPiece* src);
1040 #endif
1041
1042 template <typename T>
1043 typename std::enable_if<std::is_same<T, bool>::value, ConversionResult<T>>::type
1044 convertTo(StringPiece* src) {
1045   return str_to_bool(src);
1046 }
1047
1048 template <typename T>
1049 typename std::enable_if<
1050     std::is_floating_point<T>::value, ConversionResult<T>>::type
1051 convertTo(StringPiece* src) {
1052   return str_to_floating<T>(src);
1053 }
1054
1055 template <typename T>
1056 typename std::enable_if<
1057     std::is_integral<T>::value && !std::is_same<T, bool>::value,
1058     ConversionResult<T>>::type
1059 convertTo(StringPiece* src) {
1060   return str_to_integral<T>(src);
1061 }
1062
1063 template <typename T>
1064 struct WrapperInfo { using type = T; };
1065
1066 template <typename T, typename Gen>
1067 typename std::enable_if<
1068     std::is_same<typename WrapperInfo<T>::type, T>::value, T>::type
1069 inline wrap(ConversionResult<typename WrapperInfo<T>::type> res, Gen&& gen) {
1070   if (LIKELY(res.success())) {
1071     return res.value;
1072   }
1073   throw detail::makeConversionError(res.error, gen());
1074 }
1075
1076 } // namespace detail
1077
1078 /**
1079  * String represented as a pair of pointers to char to unsigned
1080  * integrals. Assumes NO whitespace before or after.
1081  */
1082 template <typename Tgt>
1083 typename std::enable_if<
1084     std::is_integral<typename detail::WrapperInfo<Tgt>::type>::value &&
1085     !std::is_same<typename detail::WrapperInfo<Tgt>::type, bool>::value,
1086     Tgt>::type
1087 to(const char* b, const char* e) {
1088   auto res = detail::digits_to<typename detail::WrapperInfo<Tgt>::type>(b, e);
1089   return detail::wrap<Tgt>(res, [&] { return StringPiece(b, e); });
1090 }
1091
1092 /*******************************************************************************
1093  * Conversions from string types to arithmetic types.
1094  ******************************************************************************/
1095
1096 /**
1097  * Parsing strings to numeric types. These routines differ from
1098  * parseTo(str, numeric) routines in that they take a POINTER TO a StringPiece
1099  * and alter that StringPiece to reflect progress information.
1100  */
1101 template <typename Tgt>
1102 typename std::enable_if<
1103     std::is_arithmetic<typename detail::WrapperInfo<Tgt>::type>::value>::type
1104 parseTo(StringPiece* src, Tgt& out) {
1105   auto res = detail::convertTo<typename detail::WrapperInfo<Tgt>::type>(src);
1106   out = detail::wrap<Tgt>(res, [&] { return *src; });
1107 }
1108
1109 template <typename Tgt>
1110 typename std::enable_if<
1111     std::is_arithmetic<typename detail::WrapperInfo<Tgt>::type>::value>::type
1112 parseTo(StringPiece src, Tgt& out) {
1113   auto res = detail::convertTo<typename detail::WrapperInfo<Tgt>::type>(&src);
1114   if (LIKELY(res.success())) {
1115     res.error = detail::enforceWhitespaceErr(src);
1116   }
1117   out = detail::wrap<Tgt>(res, [&] { return src; });
1118 }
1119
1120 /*******************************************************************************
1121  * Integral / Floating Point to integral / Floating Point
1122  ******************************************************************************/
1123
1124 /**
1125  * Unchecked conversion from arithmetic to boolean. This is different from the
1126  * other arithmetic conversions because we use the C convention of treating any
1127  * non-zero value as true, instead of range checking.
1128  */
1129 template <class Tgt, class Src>
1130 typename std::enable_if<
1131     std::is_arithmetic<Src>::value && !std::is_same<Tgt, Src>::value &&
1132         std::is_same<Tgt, bool>::value,
1133     Tgt>::type
1134 to(const Src& value) {
1135   return value != Src();
1136 }
1137
1138 namespace detail {
1139
1140 /**
1141  * Checked conversion from integral to integral. The checks are only
1142  * performed when meaningful, e.g. conversion from int to long goes
1143  * unchecked.
1144  */
1145 template <class Tgt, class Src>
1146 typename std::enable_if<
1147     std::is_integral<Src>::value && !std::is_same<Tgt, Src>::value &&
1148         !std::is_same<Tgt, bool>::value &&
1149         std::is_integral<Tgt>::value,
1150     ConversionResult<Tgt>>::type
1151 convertTo(const Src& value) {
1152   /* static */ if (
1153       std::numeric_limits<Tgt>::max() < std::numeric_limits<Src>::max()) {
1154     if (greater_than<Tgt, std::numeric_limits<Tgt>::max()>(value)) {
1155       return ConversionResult<Tgt>(ConversionError::ARITH_POSITIVE_OVERFLOW);
1156     }
1157   }
1158   /* static */ if (
1159       std::is_signed<Src>::value &&
1160       (!std::is_signed<Tgt>::value || sizeof(Src) > sizeof(Tgt))) {
1161     if (less_than<Tgt, std::numeric_limits<Tgt>::min()>(value)) {
1162       return ConversionResult<Tgt>(ConversionError::ARITH_NEGATIVE_OVERFLOW);
1163     }
1164   }
1165   return ConversionResult<Tgt>(static_cast<Tgt>(value));
1166 }
1167
1168 /**
1169  * Checked conversion from floating to floating. The checks are only
1170  * performed when meaningful, e.g. conversion from float to double goes
1171  * unchecked.
1172  */
1173 template <class Tgt, class Src>
1174 typename std::enable_if<
1175     std::is_floating_point<Tgt>::value && std::is_floating_point<Src>::value &&
1176         !std::is_same<Tgt, Src>::value,
1177     ConversionResult<Tgt>>::type
1178 convertTo(const Src& value) {
1179   /* static */ if (
1180       std::numeric_limits<Tgt>::max() < std::numeric_limits<Src>::max()) {
1181     if (value > std::numeric_limits<Tgt>::max()) {
1182       return ConversionResult<Tgt>(ConversionError::ARITH_POSITIVE_OVERFLOW);
1183     }
1184     if (value < std::numeric_limits<Tgt>::lowest()) {
1185       return ConversionResult<Tgt>(ConversionError::ARITH_NEGATIVE_OVERFLOW);
1186     }
1187   }
1188   return ConversionResult<Tgt>(boost::implicit_cast<Tgt>(value));
1189 }
1190
1191 /**
1192  * Check if a floating point value can safely be converted to an
1193  * integer value without triggering undefined behaviour.
1194  */
1195 template <typename Tgt, typename Src>
1196 inline typename std::enable_if<
1197     std::is_floating_point<Src>::value && std::is_integral<Tgt>::value &&
1198         !std::is_same<Tgt, bool>::value,
1199     bool>::type
1200 checkConversion(const Src& value) {
1201   constexpr Src tgtMaxAsSrc = static_cast<Src>(std::numeric_limits<Tgt>::max());
1202   constexpr Src tgtMinAsSrc = static_cast<Src>(std::numeric_limits<Tgt>::min());
1203   if (value >= tgtMaxAsSrc) {
1204     if (value > tgtMaxAsSrc) {
1205       return false;
1206     }
1207     const Src mmax = folly::nextafter(tgtMaxAsSrc, Src());
1208     if (static_cast<Tgt>(value - mmax) >
1209         std::numeric_limits<Tgt>::max() - static_cast<Tgt>(mmax)) {
1210       return false;
1211     }
1212   } else if (std::is_signed<Tgt>::value && value <= tgtMinAsSrc) {
1213     if (value < tgtMinAsSrc) {
1214       return false;
1215     }
1216     const Src mmin = folly::nextafter(tgtMinAsSrc, Src());
1217     if (static_cast<Tgt>(value - mmin) <
1218         std::numeric_limits<Tgt>::min() - static_cast<Tgt>(mmin)) {
1219       return false;
1220     }
1221   }
1222   return true;
1223 }
1224
1225 // Integers can always safely be converted to floating point values
1226 template <typename Tgt, typename Src>
1227 constexpr typename std::enable_if<
1228     std::is_integral<Src>::value && std::is_floating_point<Tgt>::value,
1229     bool>::type
1230 checkConversion(const Src&) {
1231   return true;
1232 }
1233
1234 // Also, floating point values can always be safely converted to bool
1235 // Per the standard, any floating point value that is not zero will yield true
1236 template <typename Tgt, typename Src>
1237 constexpr typename std::enable_if<
1238     std::is_floating_point<Src>::value && std::is_same<Tgt, bool>::value,
1239     bool>::type
1240 checkConversion(const Src&) {
1241   return true;
1242 }
1243
1244 /**
1245  * Checked conversion from integral to floating point and back. The
1246  * result must be convertible back to the source type without loss of
1247  * precision. This seems Draconian but sometimes is what's needed, and
1248  * complements existing routines nicely. For various rounding
1249  * routines, see <math>.
1250  */
1251 template <typename Tgt, typename Src>
1252 typename std::enable_if<
1253     (std::is_integral<Src>::value && std::is_floating_point<Tgt>::value) ||
1254         (std::is_floating_point<Src>::value && std::is_integral<Tgt>::value),
1255     ConversionResult<Tgt>>::type
1256 convertTo(const Src& value) {
1257   if (LIKELY(checkConversion<Tgt>(value))) {
1258     Tgt result = static_cast<Tgt>(value);
1259     if (LIKELY(checkConversion<Src>(result))) {
1260       Src witness = static_cast<Src>(result);
1261       if (LIKELY(value == witness)) {
1262         return ConversionResult<Tgt>(result);
1263       }
1264     }
1265   }
1266   return ConversionResult<Tgt>(ConversionError::ARITH_LOSS_OF_PRECISION);
1267 }
1268
1269 template <typename Tgt, typename Src>
1270 inline std::string errorValue(const Src& value) {
1271 #ifdef FOLLY_HAS_RTTI
1272   return to<std::string>("(", demangle(typeid(Tgt)), ") ", value);
1273 #else
1274   return to<std::string>(value);
1275 #endif
1276 }
1277
1278 template <typename Tgt, typename Src>
1279 using IsArithToArith = std::integral_constant<
1280     bool,
1281     !std::is_same<Tgt, Src>::value && !std::is_same<Tgt, bool>::value &&
1282         std::is_arithmetic<Src>::value &&
1283         std::is_arithmetic<Tgt>::value>;
1284
1285 } // namespace detail
1286
1287 template <typename Tgt, typename Src>
1288 typename std::enable_if<
1289     detail::IsArithToArith<
1290         typename detail::WrapperInfo<Tgt>::type, Src>::value, Tgt>::type
1291 to(const Src& value) {
1292   auto res = detail::convertTo<typename detail::WrapperInfo<Tgt>::type>(value);
1293   return detail::wrap<Tgt>(res, [&] {
1294     return detail::errorValue<typename detail::WrapperInfo<Tgt>::type>(value);
1295   });
1296 }
1297
1298 /*******************************************************************************
1299  * Custom Conversions
1300  *
1301  * Any type can be used with folly::to by implementing parseTo. The
1302  * implementation should be provided in the namespace of the type to facilitate
1303  * argument-dependent lookup:
1304  *
1305  * namespace other_namespace {
1306  * void parseTo(::folly::StringPiece, OtherType&);
1307  * }
1308  ******************************************************************************/
1309 template <class T>
1310 typename std::enable_if<std::is_enum<T>::value>::type
1311 parseTo(StringPiece in, T& out) {
1312   typename std::underlying_type<T>::type tmp;
1313   parseTo(in, tmp);
1314   out = static_cast<T>(tmp);
1315 }
1316
1317 inline void parseTo(StringPiece in, StringPiece& out) {
1318   out = in;
1319 }
1320
1321 inline void parseTo(StringPiece in, std::string& out) {
1322   out.clear();
1323   out.append(in.data(), in.size());
1324 }
1325
1326 inline void parseTo(StringPiece in, fbstring& out) {
1327   out.clear();
1328   out.append(in.data(), in.size());
1329 }
1330
1331 /**
1332  * String or StringPiece to target conversion. Accepts leading and trailing
1333  * whitespace, but no non-space trailing characters.
1334  */
1335
1336 template <class Tgt>
1337 typename std::enable_if<!std::is_same<StringPiece, Tgt>::value, Tgt>::type
1338 to(StringPiece src) {
1339   Tgt result;
1340   parseTo(src, result);
1341   return result;
1342 }
1343
1344 template <class Tgt>
1345 Tgt to(StringPiece* src) {
1346   Tgt result;
1347   parseTo(src, result);
1348   return result;
1349 }
1350
1351 /*******************************************************************************
1352  * Enum to anything and back
1353  ******************************************************************************/
1354
1355 template <class Tgt, class Src>
1356 typename std::enable_if<
1357   std::is_enum<Src>::value && !std::is_same<Src, Tgt>::value, Tgt>::type
1358 to(const Src & value) {
1359   return to<Tgt>(static_cast<typename std::underlying_type<Src>::type>(value));
1360 }
1361
1362 template <class Tgt, class Src>
1363 typename std::enable_if<
1364   std::is_enum<Tgt>::value && !std::is_same<Src, Tgt>::value, Tgt>::type
1365 to(const Src & value) {
1366   return static_cast<Tgt>(to<typename std::underlying_type<Tgt>::type>(value));
1367 }
1368
1369 } // namespace folly