/*
- * Copyright 2013 Facebook, Inc.
+ * Copyright 2014 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#ifndef FOLLY_BASE_CONV_H_
#define FOLLY_BASE_CONV_H_
-#include "folly/FBString.h"
-#include "folly/Likely.h"
-#include "folly/Preprocessor.h"
-#include "folly/Range.h"
+#include <folly/FBString.h>
+#include <folly/Likely.h>
+#include <folly/Preprocessor.h>
+#include <folly/Range.h>
#include <boost/implicit_cast.hpp>
#include <type_traits>
#include <limits.h>
-#include "double-conversion.h" // V8 JavaScript implementation
+// V8 JavaScript implementation
+#include <double-conversion/double-conversion.h>
#define FOLLY_RANGE_CHECK(condition, message) \
((condition) ? (void)0 : throw std::range_error( \
namespace detail {
-template <class T> struct IsSomeString {
- enum { value = std::is_same<T, std::string>::value
- || std::is_same<T, fbstring>::value };
-};
-
template <class T>
const T& getLastElement(const T & v) {
return v;
*result += value;
}
+template<class T>
+constexpr typename std::enable_if<
+ std::is_same<T, char>::value,
+ size_t>::type
+estimateSpaceNeeded(T) {
+ return 1;
+}
+
+/**
+ * Ubiquitous helper template for writing string appenders
+ */
+template <class T> struct IsSomeString {
+ enum { value = std::is_same<T, std::string>::value
+ || std::is_same<T, fbstring>::value };
+};
+
/**
* Everything implicitly convertible to const char* gets appended.
*/
template <class Tgt, class Src>
typename std::enable_if<
std::is_convertible<Src, const char*>::value
- && detail::IsSomeString<Tgt>::value>::type
+ && IsSomeString<Tgt>::value>::type
toAppend(Src value, Tgt * result) {
// Treat null pointers like an empty string, as in:
// operator<<(std::ostream&, const char*).
}
}
+template<class Src>
+typename std::enable_if<
+ std::is_convertible<Src, const char*>::value,
+ size_t>::type
+estimateSpaceNeeded(Src value) {
+ const char *c = value;
+ if (c) {
+ return folly::StringPiece(value).size();
+ };
+ return 0;
+}
+
+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) {
+ return folly::StringPiece(value).size();
+}
+
+template<class Src>
+typename std::enable_if<
+ std::is_pointer<Src>::value &&
+ IsSomeString<std::remove_pointer<Src>>::value,
+ size_t>::type
+estimateSpaceNeeded(Src value) {
+ return value->size();
+}
+
/**
* Strings get appended, too.
*/
template <class Tgt, class Src>
typename std::enable_if<
- detail::IsSomeString<Src>::value && detail::IsSomeString<Tgt>::value>::type
+ IsSomeString<Src>::value && IsSomeString<Tgt>::value>::type
toAppend(const Src& value, Tgt * result) {
result->append(value);
}
*/
template <class Tgt>
typename std::enable_if<
- detail::IsSomeString<Tgt>::value>::type
+ IsSomeString<Tgt>::value>::type
toAppend(StringPiece value, Tgt * result) {
result->append(value.data(), value.size());
}
*/
template <class Tgt>
typename std::enable_if<
- detail::IsSomeString<Tgt>::value>::type
+ IsSomeString<Tgt>::value>::type
toAppend(const fbstring& value, Tgt * result) {
result->append(value.data(), value.size());
}
result->append(buffer + p, buffer + sizeof(buffer));
}
+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
/**
template <class Tgt, class Src>
typename std::enable_if<
std::is_integral<Src>::value && std::is_signed<Src>::value &&
- detail::IsSomeString<Tgt>::value && sizeof(Src) >= 4>::type
+ IsSomeString<Tgt>::value && sizeof(Src) >= 4>::type
toAppend(Src value, Tgt * result) {
char buffer[20];
if (value < 0) {
}
}
+template <class Src>
+typename std::enable_if<
+ std::is_integral<Src>::value && std::is_signed<Src>::value
+ && sizeof(Src) >= 4 && sizeof(Src) < 16,
+ size_t>::type
+estimateSpaceNeeded(Src value) {
+ if (value < 0) {
+ return 1 + digits10(static_cast<uint64_t>(-value));
+ }
+
+ return digits10(static_cast<uint64_t>(value));
+}
+
/**
* As above, but for uint32_t and uint64_t.
*/
template <class Tgt, class Src>
typename std::enable_if<
std::is_integral<Src>::value && !std::is_signed<Src>::value
- && detail::IsSomeString<Tgt>::value && sizeof(Src) >= 4>::type
+ && IsSomeString<Tgt>::value && sizeof(Src) >= 4>::type
toAppend(Src value, Tgt * result) {
char buffer[20];
result->append(buffer, buffer + uint64ToBufferUnsafe(value, buffer));
}
+template <class Src>
+typename std::enable_if<
+ std::is_integral<Src>::value && !std::is_signed<Src>::value
+ && sizeof(Src) >= 4 && sizeof(Src) < 16,
+ size_t>::type
+estimateSpaceNeeded(Src value) {
+ return digits10(value);
+}
+
/**
* All small signed and unsigned integers to string go through 32-bit
* types int32_t and uint32_t, respectively.
template <class Tgt, class Src>
typename std::enable_if<
std::is_integral<Src>::value
- && detail::IsSomeString<Tgt>::value && sizeof(Src) < 4>::type
+ && IsSomeString<Tgt>::value && sizeof(Src) < 4>::type
toAppend(Src value, Tgt * result) {
typedef typename
std::conditional<std::is_signed<Src>::value, int64_t, uint64_t>::type
toAppend<Tgt>(static_cast<Intermediate>(value), result);
}
-#if defined(__GNUC__) && __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)
+template <class Src>
+typename std::enable_if<
+ std::is_integral<Src>::value
+ && sizeof(Src) < 4
+ && !std::is_same<Src, char>::value,
+ size_t>::type
+estimateSpaceNeeded(Src value) {
+ typedef typename
+ std::conditional<std::is_signed<Src>::value, int64_t, uint64_t>::type
+ Intermediate;
+ return estimateSpaceNeeded(static_cast<Intermediate>(value));
+}
+
+#if defined(__clang__) || __GNUC_PREREQ(4, 7)
// std::underlying_type became available by gcc 4.7.0
/**
*/
template <class Tgt, class Src>
typename std::enable_if<
- std::is_enum<Src>::value && detail::IsSomeString<Tgt>::value>::type
+ std::is_enum<Src>::value && IsSomeString<Tgt>::value>::type
toAppend(Src value, Tgt * result) {
toAppend(
static_cast<typename std::underlying_type<Src>::type>(value), result);
}
+template <class Src>
+typename std::enable_if<
+ std::is_enum<Src>::value, size_t>::type
+estimateSpaceNeeded(Src value) {
+ return estimateSpaceNeeded(
+ static_cast<typename std::underlying_type<Src>::type>(value));
+}
+
#else
/**
*/
template <class Tgt, class Src>
typename std::enable_if<
- std::is_enum<Src>::value && detail::IsSomeString<Tgt>::value>::type
+ std::is_enum<Src>::value && IsSomeString<Tgt>::value>::type
toAppend(Src value, Tgt * result) {
/* static */ if (Src(-1) < 0) {
/* static */ if (sizeof(Src) <= sizeof(int)) {
}
}
+template <class Src>
+typename std::enable_if<
+ std::is_enum<Src>::value, size_t>::type
+estimateSpaceNeeded(Src value) {
+ /* static */ if (Src(-1) < 0) {
+ /* static */ if (sizeof(Src) <= sizeof(int)) {
+ return estimateSpaceNeeded(static_cast<int>(value));
+ } else {
+ return estimateSpaceNeeded(static_cast<long>(value));
+ }
+ } else {
+ /* static */ if (sizeof(Src) <= sizeof(int)) {
+ return estimateSpaceNeeded(static_cast<unsigned int>(value));
+ } else {
+ return estimateSpaceNeeded(static_cast<unsigned long>(value));
+ }
+ }
+}
+
#endif // gcc 4.7 onwards
/*******************************************************************************
template <class Tgt, class Src>
typename std::enable_if<
std::is_floating_point<Src>::value
- && detail::IsSomeString<Tgt>::value>::type
+ && IsSomeString<Tgt>::value>::type
toAppend(
Src value,
Tgt * result,
template <class Tgt, class Src>
typename std::enable_if<
std::is_floating_point<Src>::value
- && detail::IsSomeString<Tgt>::value>::type
+ && IsSomeString<Tgt>::value>::type
toAppend(Src value, Tgt * result) {
toAppend(
value, result, double_conversion::DoubleToStringConverter::SHORTEST, 0);
}
/**
- * Variadic conversion to string. Appends each element in turn.
+ * Very primitive, lets say its our best effort
+ */
+template <class Src>
+typename std::enable_if<
+ std::is_floating_point<Src>::value, size_t>::type
+estimateSpaceNeeded(Src value) {
+ size_t sofar = 0;
+ if (value < 0) {
+ ++sofar;
+ value = -value;
+ }
+
+ if (value < 1) {
+ return sofar + 10; // lets assume 0 + '.' + 8 precision digits
+ }
+
+ if (value < static_cast<double>(std::numeric_limits<uint64_t>::max())) {
+ sofar += digits10(static_cast<uint64_t>(value));
+ } else {
+ return 64; // give up, it will be more than 23 anyway
+ }
+
+ return sofar + 10; // integral part + '.' + 8 precision digits
+}
+
+/**
+ * This can be specialized, together with adding specialization
+ * for estimateSpaceNeed for your type, so that we allocate
+ * as much as you need instead of the default
+ */
+template<class Src>
+struct HasLengthEstimator : std::false_type {};
+
+template <class Src>
+constexpr typename std::enable_if<
+ !std::is_fundamental<Src>::value
+ && !IsSomeString<Src>::value
+ && !std::is_convertible<Src, const char*>::value
+ && !std::is_convertible<Src, StringPiece>::value
+ && !std::is_enum<Src>::value
+ && !HasLengthEstimator<Src>::value,
+ size_t>::type
+estimateSpaceNeeded(const Src&) {
+ return sizeof(Src) + 1; // dumbest best effort ever?
+}
+
+namespace detail {
+
+inline size_t estimateSpaceToReserve(size_t sofar) {
+ return sofar;
+}
+
+template <class T, class... Ts>
+size_t estimateSpaceToReserve(size_t sofar, const T& v, const Ts&... vs) {
+ return estimateSpaceToReserve(sofar + estimateSpaceNeeded(v), vs...);
+}
+
+template<class T>
+size_t estimateSpaceToReserve(size_t sofar, const T& v) {
+ return sofar + estimateSpaceNeeded(v);
+}
+
+template<class...Ts>
+void reserveInTarget(const Ts&...vs) {
+ getLastElement(vs...)->reserve(estimateSpaceToReserve(0, vs...));
+}
+
+template<class Delimiter, class...Ts>
+void reserveInTargetDelim(const Delimiter& d, const Ts&...vs) {
+ static_assert(sizeof...(vs) >= 2, "Needs at least 2 args");
+ size_t fordelim = (sizeof...(vs) - 2) * estimateSpaceToReserve(0, d);
+ getLastElement(vs...)->reserve(estimateSpaceToReserve(fordelim, vs...));
+}
+
+/**
+ * Variadic base case: append one element
*/
+template <class T, class Tgt>
+typename std::enable_if<
+ IsSomeString<typename std::remove_pointer<Tgt>::type>
+ ::value>::type
+toAppendStrImpl(const T& v, Tgt result) {
+ toAppend(v, result);
+}
+
template <class T, class... Ts>
typename std::enable_if<sizeof...(Ts) >= 2
- && detail::IsSomeString<
+ && IsSomeString<
+ typename std::remove_pointer<
+ typename detail::last_element<Ts...>::type
+ >::type>::value>::type
+toAppendStrImpl(const T& v, const Ts&... vs) {
+ toAppend(v, getLastElement(vs...));
+ toAppendStrImpl(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) {
+ toAppend(v, result);
+}
+
+template <class Delimiter, class T, class... Ts>
+typename std::enable_if<sizeof...(Ts) >= 2
+ && IsSomeString<
typename std::remove_pointer<
typename detail::last_element<Ts...>::type
>::type>::value>::type
-toAppend(const T& v, const Ts&... vs) {
+toAppendDelimStrImpl(const Delimiter& delim, const T& v, const Ts&... vs) {
+ // we are really careful here, calling toAppend with just one element does
+ // not try to estimate space needed (as we already did that). If we call
+ // toAppend(v, delim, ....) we would do unnecesary size calculation
toAppend(v, detail::getLastElement(vs...));
- toAppend(vs...);
+ toAppend(delim, detail::getLastElement(vs...));
+ toAppendDelimStrImpl(delim, vs...);
+}
+} // folly::detail
+
+
+/**
+ * Variadic conversion to string. Appends each element in turn.
+ * If we have two or more things to append, we will reserve
+ * the space for them (at least we will try).
+ */
+template <class... Ts>
+typename std::enable_if<sizeof...(Ts) >= 3
+ && IsSomeString<
+ typename std::remove_pointer<
+ typename detail::last_element<Ts...>::type
+ >::type>::value>::type
+toAppend(const Ts&... vs) {
+ detail::reserveInTarget(vs...);
+ detail::toAppendStrImpl(vs...);
}
/**
* Variadic base case: do nothing.
*/
template <class Tgt>
-typename std::enable_if<detail::IsSomeString<Tgt>::value>::type
+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<detail::IsSomeString<Tgt>::value>::type
+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<detail::IsSomeString<Tgt>::value>::type
+typename std::enable_if<IsSomeString<Tgt>::value>::type
toAppendDelim(const Delimiter& delim, const T& v, Tgt* tgt) {
toAppend(v, tgt);
}
/**
* Append to string with a delimiter in between elements.
*/
-template <class Delimiter, class T, class... Ts>
-typename std::enable_if<sizeof...(Ts) >= 2
- && detail::IsSomeString<
+template <class Delimiter, class... Ts>
+typename std::enable_if<sizeof...(Ts) >= 3
+ && IsSomeString<
typename std::remove_pointer<
typename detail::last_element<Ts...>::type
>::type>::value>::type
-toAppendDelim(const Delimiter& delim, const T& v, const Ts&... vs) {
- toAppend(v, delim, detail::getLastElement(vs...));
- toAppendDelim(delim, vs...);
+toAppendDelim(const Delimiter& delim, const Ts&... vs) {
+ detail::reserveInTargetDelim(delim, vs...);
+ detail::toAppendDelimStrImpl(delim, vs...);
+}
+
+/**
+ * to<SomeString>(SomeString str) returns itself. As both std::string and
+ * folly::fbstring use Copy-on-Write, it's much more efficient by
+ * avoiding copying the underlying char array.
+ */
+template <class Tgt, class Src>
+typename std::enable_if<
+ IsSomeString<Tgt>::value && std::is_same<Tgt, Src>::value,
+ Tgt>::type
+to(const Src & value) {
+ return value;
}
/**
* for all types.
*/
template <class Tgt, class... Ts>
-typename std::enable_if<detail::IsSomeString<Tgt>::value, Tgt>::type
+typename std::enable_if<
+ IsSomeString<Tgt>::value && (
+ sizeof...(Ts) != 1 ||
+ !std::is_same<Tgt, typename detail::last_element<Ts...>::type>::value),
+ Tgt>::type
to(const Ts&... vs) {
Tgt result;
toAppend(vs..., &result);
return result;
}
+/**
+ * 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) {
+ return value;
+}
+
/**
* toDelim<SomeString>(delim, v1, v2, ...) uses toAppendDelim() as
* back-end for all types.
*/
template <class Tgt, class Delim, class... Ts>
-typename std::enable_if<detail::IsSomeString<Tgt>::value, Tgt>::type
+typename std::enable_if<
+ IsSomeString<Tgt>::value && (
+ sizeof...(Ts) != 1 ||
+ !std::is_same<Tgt, typename detail::last_element<Ts...>::type>::value),
+ Tgt>::type
toDelim(const Delim& delim, const Ts&... vs) {
Tgt result;
toAppendDelim(delim, vs..., &result);
// still not overflow uint16_t.
constexpr int32_t OOR = 10000;
-__attribute__((aligned(16))) constexpr uint16_t shift1[] = {
+__attribute__((__aligned__(16))) constexpr uint16_t shift1[] = {
OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 0-9
OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 10
OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 20
OOR, OOR, OOR, OOR, OOR, OOR // 250
};
-__attribute__((aligned(16))) constexpr uint16_t shift10[] = {
+__attribute__((__aligned__(16))) constexpr uint16_t shift10[] = {
OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 0-9
OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 10
OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 20
OOR, OOR, OOR, OOR, OOR, OOR // 250
};
-__attribute__((aligned(16))) constexpr uint16_t shift100[] = {
+__attribute__((__aligned__(16))) constexpr uint16_t shift100[] = {
OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 0-9
OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 10
OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 20
OOR, OOR, OOR, OOR, OOR, OOR // 250
};
-__attribute__((aligned(16))) constexpr uint16_t shift1000[] = {
+__attribute__((__aligned__(16))) constexpr uint16_t shift1000[] = {
OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 0-9
OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 10
OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 20
* Enum to anything and back
******************************************************************************/
-#if defined(__GNUC__) && __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)
+#if defined(__clang__) || __GNUC_PREREQ(4, 7)
// std::underlying_type became available by gcc 4.7.0
template <class Tgt, class Src>
projects / folly.git / blobdiff