Fix GlogFormatterTest on Windows

[folly.git] / folly / String.h

diff --git a/folly/String.h b/folly/String.h
index ba43160d5606609559d123dcda5a847d3cbb6a91..80d3e232375aa9c91d6dadbd2187748ca6d0db5b 100644 (file)
--- a/folly/String.h
+++ b/folly/String.h
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016 Facebook, Inc.
+ * Copyright 2017 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -20,21 +20,15 @@
 #include <exception>
 #include <stdarg.h>
 #include <string>
+#include <vector>
 #include <boost/type_traits.hpp>
 #include <boost/regex/pending/unicode_iterator.hpp>
 
-#ifdef FOLLY_HAVE_DEPRECATED_ASSOC
-#ifdef _GLIBCXX_SYMVER
-#include <ext/hash_set>
-#include <ext/hash_map>
-#endif
-#endif
-
 #include <unordered_set>
 #include <unordered_map>
 
 #include <folly/Conv.h>
-#include <folly/Demangle.h>
+#include <folly/ExceptionString.h>
 #include <folly/FBString.h>
 #include <folly/FBVector.h>
 #include <folly/Portability.h>
@@ -259,6 +253,21 @@ template<class InputString, class OutputString>
 bool hexlify(const InputString& input, OutputString& output,
              bool append=false);
 
+template <class OutputString = std::string>
+OutputString hexlify(ByteRange input) {
+  OutputString output;
+  if (!hexlify(input, output)) {
+    // hexlify() currently always returns true, so this can't really happen
+    throw std::runtime_error("hexlify failed");
+  }
+  return output;
+}
+
+template <class OutputString = std::string>
+OutputString hexlify(StringPiece input) {
+  return hexlify<OutputString>(ByteRange{input});
+}
+
 /**
  * Same functionality as Python's binascii.unhexlify.  Returns true
  * on successful conversion.
@@ -266,6 +275,17 @@ bool hexlify(const InputString& input, OutputString& output,
 template<class InputString, class OutputString>
 bool unhexlify(const InputString& input, OutputString& output);
 
+template <class OutputString = std::string>
+OutputString unhexlify(StringPiece input) {
+  OutputString output;
+  if (!unhexlify(input, output)) {
+    // unhexlify() fails if the input has non-hexidecimal characters,
+    // or if it doesn't consist of a whole number of bytes
+    throw std::domain_error("unhexlify() called with non-hex input");
+  }
+  return output;
+}
+
 /*
  * A pretty-printer for numbers that appends suffixes of units of the
  * given type.  It prints 4 sig-figs of value with the most
@@ -360,45 +380,6 @@ std::string hexDump(const void* ptr, size_t size);
  */
 fbstring errnoStr(int err);
 
-/**
- * Debug string for an exception: include type and what(), if
- * defined.
- */
-inline fbstring exceptionStr(const std::exception& e) {
-#ifdef FOLLY_HAS_RTTI
-  return folly::to<fbstring>(demangle(typeid(e)), ": ", e.what());
-#else
-  return folly::to<fbstring>("Exception (no RTTI available): ", e.what());
-#endif
-}
-
-// Empirically, this indicates if the runtime supports
-// std::exception_ptr, as not all (arm, for instance) do.
-#if defined(__GNUC__) && defined(__GCC_ATOMIC_INT_LOCK_FREE) && \
-  __GCC_ATOMIC_INT_LOCK_FREE > 1
-inline fbstring exceptionStr(std::exception_ptr ep) {
-  try {
-    std::rethrow_exception(ep);
-  } catch (const std::exception& e) {
-    return exceptionStr(e);
-  } catch (...) {
-    return "<unknown exception>";
-  }
-}
-#endif
-
-template<typename E>
-auto exceptionStr(const E& e)
-  -> typename std::enable_if<!std::is_base_of<std::exception, E>::value,
-                             fbstring>::type
-{
-#ifdef FOLLY_HAS_RTTI
-  return folly::to<fbstring>(demangle(typeid(e)));
-#else
-  return "Exception (no RTTI available)";
-#endif
-}
-
 /*
  * Split a string into a list of tokens by delimiter.
  *
@@ -504,7 +485,8 @@ struct IsConvertible {
 template <class T>
 struct IsConvertible<
     T,
-    decltype(parseTo(std::declval<folly::StringPiece>(), std::declval<T&>()))> {
+    decltype(static_cast<void>(
+        parseTo(std::declval<folly::StringPiece>(), std::declval<T&>())))> {
   enum { value = true };
 };
 
@@ -657,12 +639,4 @@ using UTF8StringPiece = UTF8Range<const char*>;
 
 } // namespace folly
 
-// Hook into boost's type traits
-namespace boost {
-template <class T>
-struct has_nothrow_constructor<folly::basic_fbstring<T> > : true_type {
-  enum { value = true };
-};
-} // namespace boost
-
 #include <folly/String-inl.h>