#ifndef FOLLY_BASE_STRING_H_
#define FOLLY_BASE_STRING_H_
+#include <exception>
#include <string>
#include <boost/type_traits.hpp>
std::string& stringAppendf(std::string* output, const char* format, ...)
__attribute__ ((format (printf, 2, 3)));
+/**
+ * Backslashify a string, that is, replace non-printable characters
+ * with C-style (but NOT C compliant) "\xHH" encoding. If hex_style
+ * is false, then shorthand notations like "\0" will be used instead
+ * of "\x00" for the most common backslash cases.
+ *
+ * There are two forms, one returning the input string, and one
+ * creating output in the specified output string.
+ *
+ * This is mainly intended for printing to a terminal, so it is not
+ * particularly optimized.
+ *
+ * Do *not* use this in situations where you expect to be able to feed
+ * the string to a C or C++ compiler, as there are nuances with how C
+ * parses such strings that lead to failures. This is for display
+ * purposed only. If you want a string you can embed for use in C or
+ * C++, use cEscape instead. This function is for display purposes
+ * only.
+ */
+template <class String1, class String2>
+void backslashify(const String1& input, String2& output, bool hex_style=false);
+
+template <class String>
+String backslashify(const String& input, bool hex_style=false) {
+ String output;
+ backslashify(input, output, hex_style);
+ return output;
+}
+
+/**
+ * Take a string and "humanify" it -- that is, make it look better.
+ * Since "better" is subjective, caveat emptor. The basic approach is
+ * to count the number of unprintable characters. If there are none,
+ * then the output is the input. If there are relatively few, or if
+ * there is a long "enough" prefix of printable characters, use
+ * backslashify. If it is mostly binary, then simply hex encode.
+ *
+ * This is an attempt to make a computer smart, and so likely is wrong
+ * most of the time.
+ */
+template <class String1, class String2>
+void humanify(const String1& input, String2& output);
+
+template <class String>
+String humanify(const String& input) {
+ String output;
+ humanify(input, output);
+ return output;
+}
+
+/**
+ * Same functionality as Python's binascii.hexlify. Returns true
+ * on successful conversion.
+ *
+ * If append_output is true, append data to the output rather than
+ * replace it.
+ */
+template<class InputString, class OutputString>
+bool hexlify(const InputString& input, OutputString& output,
+ bool append=false);
+
+/**
+ * Same functionality as Python's binascii.unhexlify. Returns true
+ * on successful conversion.
+ */
+template<class InputString, class OutputString>
+bool unhexlify(const InputString& input, OutputString& 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
*
* Current types are:
* PRETTY_TIME - s, ms, us, ns, etc.
- * PRETTY_BYTES - kb, MB, GB, etc (goes up by 2^10 = 1024 each time)
- * PRETTY_BYTES_METRIC - kb, MB, GB, etc (goes up by 10^3 = 1000 each time)
+ * PRETTY_BYTES_METRIC - kB, MB, GB, etc (goes up by 10^3 = 1000 each time)
+ * PRETTY_BYTES - kB, MB, GB, etc (goes up by 2^10 = 1024 each time)
+ * PRETTY_BYTES_IEC - KiB, MiB, GiB, etc
* PRETTY_UNITS_METRIC - k, M, G, etc (goes up by 10^3 = 1000 each time)
* PRETTY_UNITS_BINARY - k, M, G, etc (goes up by 2^10 = 1024 each time)
+ * PRETTY_UNITS_BINARY_IEC - Ki, Mi, Gi, etc
*
* @author Mark Rabkin <mrabkin@fb.com>
*/
enum PrettyType {
PRETTY_TIME,
- PRETTY_BYTES,
+
PRETTY_BYTES_METRIC,
+ PRETTY_BYTES_BINARY,
+ PRETTY_BYTES = PRETTY_BYTES_BINARY,
+ PRETTY_BYTES_BINARY_IEC,
+ PRETTY_BYTES_IEC = PRETTY_BYTES_BINARY_IEC,
+
PRETTY_UNITS_METRIC,
PRETTY_UNITS_BINARY,
+ PRETTY_UNITS_BINARY_IEC,
PRETTY_NUM_TYPES
};
return folly::to<fbstring>(demangle(typeid(e)), ": ", e.what());
}
+inline fbstring exceptionStr(std::exception_ptr ep) {
+ try {
+ std::rethrow_exception(ep);
+ } catch (const std::exception& e) {
+ return exceptionStr(e);
+ } catch (...) {
+ return "<unknown exception>";
+ }
+}
+
/*
* Split a string into a list of tokens by delimiter.
*
* The split interface here supports different output types, selected
* at compile time: StringPiece, fbstring, or std::string. If you are
* using a vector to hold the output, it detects the type based on
- * what your vector contains.
+ * what your vector contains. If the output vector is not empty, split
+ * will append to the end of the vector.
*
* You can also use splitTo() to write the output to an arbitrary
* OutputIterator (e.g. std::inserter() on a std::set<>), in which
* case you have to tell the function the type. (Rationale:
* OutputIterators don't have a value_type, so we can't detect the
- * type in split without being told.)
+ * type in splitTo without being told.)
*
* Examples:
*
* folly::splitTo<StringPiece>(":", "asd:bsd:asd:csd",
* std::inserter(s, s.begin()));
*
- * Split also takes a flag (ignoreEmpty) that indicates whether
- * adjacent tokens should be treated as one separator or not. Note
- * that unlikely strtok() the default is to treat them as separators.
+ * Split also takes a flag (ignoreEmpty) that indicates whether adjacent
+ * delimiters should be treated as one single separator (ignoring empty tokens)
+ * or not (generating empty tokens).
*/
template<class Delim, class String, class OutputType>
OutputIterator out,
bool ignoreEmpty = false);
+/*
+ * Join list of tokens.
+ *
+ * Stores a string representation of tokens in the same order with
+ * deliminer between each element.
+ */
+
+template <class Delim, class Iterator, class String>
+void join(const Delim& delimiter,
+ Iterator begin,
+ Iterator end,
+ String& output);
+
+template <class Delim, class Container, class String>
+void join(const Delim& delimiter,
+ const Container& container,
+ String& output) {
+ join(delimiter, container.begin(), container.end(), output);
+}
+
+template <class Delim, class Container>
+std::string join(const Delim& delimiter,
+ const Container& container) {
+ std::string output;
+ join(delimiter, container.begin(), container.end(), output);
+ return output;
+}
+
} // namespace folly
// Hash functions for string and fbstring usable with e.g. hash_map
projects / folly.git / blobdiff