Create the dirent.h portability header

[folly.git] / folly / Conv.h

diff --git a/folly/Conv.h b/folly/Conv.h
index 4acb9c1e40aa995da9de2477a7ac8264b90cec5b..b730857bf68f9dcd5c04e2b2b439fa180856a2a3 100644 (file)
--- a/folly/Conv.h
+++ b/folly/Conv.h
@@ -1,5 +1,5 @@
 /*
- * Copyright 2015 Facebook, Inc.
+ * 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.
@@ -21,8 +21,7 @@
  * @author Andrei Alexandrescu (andrei.alexandrescu@fb.com)
  */
 
-#ifndef FOLLY_BASE_CONV_H_
-#define FOLLY_BASE_CONV_H_
+#pragma once
 
 #include <folly/FBString.h>
 #include <folly/Likely.h>
@@ -202,7 +201,7 @@ namespace detail {
 template <typename IntegerType>
 constexpr unsigned int
 digitsEnough() {
-  return ceil((double(sizeof(IntegerType) * CHAR_BIT) * M_LN2) / M_LN10);
+  return (unsigned int)(ceil(sizeof(IntegerType) * CHAR_BIT * M_LN2 / M_LN10));
 }
 
 inline size_t
@@ -388,6 +387,11 @@ estimateSpaceNeeded(Src value) {
   return folly::StringPiece(value).size();
 }
 
+template <>
+inline size_t estimateSpaceNeeded(std::nullptr_t /* value */) {
+  return 0;
+}
+
 template<class Src>
 typename std::enable_if<
   std::is_pointer<Src>::value &&
@@ -508,7 +512,10 @@ typename std::enable_if<
   size_t>::type
 estimateSpaceNeeded(Src value) {
   if (value < 0) {
-    return 1 + digits10(static_cast<uint64_t>(-value));
+    // When "value" is the smallest negative, negating it would evoke
+    // undefined behavior, so, instead of writing "-value" below, we write
+    // "~static_cast<uint64_t>(value) + 1"
+    return 1 + digits10(~static_cast<uint64_t>(value) + 1);
   }
 
   return digits10(static_cast<uint64_t>(value));
@@ -746,9 +753,8 @@ toAppendStrImpl(const T& v, const Ts&... vs) {
 
 template <class Delimiter, class T, class Tgt>
 typename std::enable_if<
-  IsSomeString<typename std::remove_pointer<Tgt>::type>
-  ::value>::type
-toAppendDelimStrImpl(const Delimiter& delim, const T& v, Tgt result) {
+    IsSomeString<typename std::remove_pointer<Tgt>::type>::value>::type
+toAppendDelimStrImpl(const Delimiter& /* delim */, const T& v, Tgt result) {
   toAppend(v, result);
 }
 
@@ -786,6 +792,17 @@ 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 <class Tgt>
+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
@@ -813,24 +830,22 @@ void toAppendFit(const Ts&) {}
  * Variadic base case: do nothing.
  */
 template <class Tgt>
-typename std::enable_if<IsSomeString<Tgt>::value>::type
-toAppend(Tgt* result) {
-}
+typename std::enable_if<IsSomeString<Tgt>::value>::type toAppend(
+    Tgt* /* result */) {}
 
 /**
  * Variadic base case: do nothing.
  */
 template <class Delimiter, class Tgt>
-typename std::enable_if<IsSomeString<Tgt>::value>::type
-toAppendDelim(const Delimiter& delim, Tgt* result) {
-}
+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) {
+typename std::enable_if<IsSomeString<Tgt>::value>::type toAppendDelim(
+    const Delimiter& /* delim */, const T& v, Tgt* tgt) {
   toAppend(v, tgt);
 }
 
@@ -885,10 +900,10 @@ to(const Ts&... vs) {
  * toDelim<SomeString>(SomeString str) returns itself.
  */
 template <class Tgt, class Delim, class Src>
-typename std::enable_if<
-  IsSomeString<Tgt>::value && std::is_same<Tgt, Src>::value,
-  Tgt>::type
-toDelim(const Delim& delim, const Src & value) {
+typename std::enable_if<IsSomeString<Tgt>::value &&
+                            std::is_same<Tgt, Src>::value,
+                        Tgt>::type
+toDelim(const Delim& /* delim */, const Src& value) {
   return value;
 }
 
@@ -1214,7 +1229,7 @@ typename std::enable_if<
   std::is_floating_point<Tgt>::value,
   Tgt>::type
 to(StringPiece src) {
-  Tgt result = to<double>(&src);
+  Tgt result = Tgt(to<double>(&src));
   detail::enforceWhitespace(src.data(), src.data() + src.size());
   return result;
 }
@@ -1224,7 +1239,7 @@ to(StringPiece src) {
  ******************************************************************************/
 
 /**
- * Checked conversion from integral to flating point and back. The
+ * 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
@@ -1237,7 +1252,7 @@ typename std::enable_if<
   (std::is_floating_point<Src>::value && std::is_integral<Tgt>::value),
   Tgt>::type
 to(const Src & value) {
-  Tgt result = value;
+  Tgt result = Tgt(value);
   auto witness = static_cast<Src>(result);
   if (value != witness) {
     throw std::range_error(
@@ -1282,5 +1297,3 @@ to(const Src & value) {
 #undef FOLLY_RANGE_CHECK_STRINGIZE
 #undef FOLLY_RANGE_CHECK_STRINGIZE2
 #endif
-
-#endif /* FOLLY_BASE_CONV_H_ */