497 lines
16 KiB
C++
497 lines
16 KiB
C++
// Copyright Louis Delacroix 2010 - 2014.
|
|
// Distributed under the Boost Software License, Version 1.0.
|
|
// (See accompanying file LICENSE_1_0.txt or copy at
|
|
// http://www.boost.org/LICENSE_1_0.txt)
|
|
//
|
|
// A pretty printing library for C++
|
|
//
|
|
// The global operator<< overload hs been removed
|
|
|
|
#ifndef SOI_HEADER_PRETTY_PRINT
|
|
#define SOI_HEADER_PRETTY_PRINT
|
|
|
|
#include <cstddef>
|
|
#include <iterator>
|
|
#include <memory>
|
|
#include <ostream>
|
|
#include <set>
|
|
#include <tuple>
|
|
#include <type_traits>
|
|
#include <unordered_set>
|
|
#include <utility>
|
|
#include <valarray>
|
|
|
|
namespace soi {
|
|
|
|
namespace prettyprint {
|
|
|
|
template <typename T, typename TChar, typename TCharTraits>
|
|
std::basic_ostream<TChar, TCharTraits> &
|
|
print(std::basic_ostream<TChar, TCharTraits> &stream, const T &x);
|
|
|
|
namespace detail {
|
|
// SFINAE type trait to detect whether T::const_iterator exists.
|
|
|
|
struct sfinae_base {
|
|
using yes = char;
|
|
using no = yes[2];
|
|
};
|
|
|
|
template <typename T> struct has_const_iterator : private sfinae_base {
|
|
private:
|
|
template <typename C> static yes &test(typename C::const_iterator *);
|
|
template <typename C> static no &test(...);
|
|
|
|
public:
|
|
static const bool value = sizeof(test<T>(nullptr)) == sizeof(yes);
|
|
using type = T;
|
|
};
|
|
|
|
template <typename T> struct has_begin_end : private sfinae_base {
|
|
private:
|
|
template <typename C>
|
|
static yes &
|
|
f(typename std::enable_if<
|
|
std::is_same<decltype(static_cast<typename C::const_iterator (C::*)()
|
|
const>(&C::begin)),
|
|
typename C::const_iterator (C::*)() const>::value>::type *);
|
|
|
|
template <typename C> static no &f(...);
|
|
|
|
template <typename C>
|
|
static yes &
|
|
g(typename std::enable_if<
|
|
std::is_same<decltype(static_cast<typename C::const_iterator (C::*)()
|
|
const>(&C::end)),
|
|
typename C::const_iterator (C::*)() const>::value,
|
|
void>::type *);
|
|
|
|
template <typename C> static no &g(...);
|
|
|
|
public:
|
|
static bool const beg_value = sizeof(f<T>(nullptr)) == sizeof(yes);
|
|
static bool const end_value = sizeof(g<T>(nullptr)) == sizeof(yes);
|
|
};
|
|
|
|
} // namespace detail
|
|
|
|
// Holds the delimiter values for a specific character type
|
|
|
|
template <typename TChar> struct delimiters_values {
|
|
using char_type = TChar;
|
|
const char_type *prefix;
|
|
const char_type *delimiter;
|
|
const char_type *postfix;
|
|
};
|
|
|
|
// Defines the delimiter values for a specific container and character type
|
|
|
|
template <typename T, typename TChar> struct delimiters {
|
|
using type = delimiters_values<TChar>;
|
|
static const type values;
|
|
};
|
|
|
|
// Functor to pretty_print containers. You can use this directly if you want
|
|
// to specificy a non-default delimiters type. The pretty_printing logic can
|
|
// be customized by specializing the nested template.
|
|
|
|
template <typename T, typename TChar = char,
|
|
typename TCharTraits = ::std::char_traits<TChar>,
|
|
typename TDelimiters = delimiters<T, TChar>>
|
|
struct pretty_print_container_helper {
|
|
using delimiters_type = TDelimiters;
|
|
using ostream_type = std::basic_ostream<TChar, TCharTraits>;
|
|
|
|
template <typename U> struct pretty_printer {
|
|
static void pretty_print_body(const U &c, ostream_type &stream) {
|
|
using std::begin;
|
|
using std::end;
|
|
|
|
auto it = begin(c);
|
|
const auto the_end = end(c);
|
|
|
|
if (it != the_end) {
|
|
for (;;) {
|
|
::soi::prettyprint::print(stream, *it);
|
|
|
|
if (++it == the_end)
|
|
break;
|
|
|
|
if (delimiters_type::values.delimiter != NULL)
|
|
::soi::prettyprint::print(stream, delimiters_type::values.delimiter);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
pretty_print_container_helper(const T &container) : container_(container) {}
|
|
|
|
inline void operator()(ostream_type &stream) const {
|
|
if (delimiters_type::values.prefix != NULL)
|
|
::soi::prettyprint::print(stream, delimiters_type::values.prefix);
|
|
|
|
pretty_printer<T>::pretty_print_body(container_, stream);
|
|
|
|
if (delimiters_type::values.postfix != NULL)
|
|
::soi::prettyprint::print(stream, delimiters_type::values.postfix);
|
|
}
|
|
|
|
private:
|
|
const T &container_;
|
|
};
|
|
|
|
// Specialization for pairs
|
|
|
|
template <typename T, typename TChar, typename TCharTraits,
|
|
typename TDelimiters>
|
|
template <typename T1, typename T2>
|
|
struct pretty_print_container_helper<
|
|
T, TChar, TCharTraits, TDelimiters>::pretty_printer<std::pair<T1, T2>> {
|
|
using ostream_type =
|
|
typename pretty_print_container_helper<T, TChar, TCharTraits,
|
|
TDelimiters>::ostream_type;
|
|
|
|
static void pretty_print_body(const std::pair<T1, T2> &c,
|
|
ostream_type &stream) {
|
|
::soi::prettyprint::print(stream, c.first);
|
|
if (pretty_print_container_helper<T, TChar, TCharTraits,
|
|
TDelimiters>::delimiters_type::values
|
|
.delimiter != NULL)
|
|
::soi::prettyprint::print(
|
|
stream,
|
|
pretty_print_container_helper<T, TChar, TCharTraits,
|
|
TDelimiters>::delimiters_type::values
|
|
.delimiter);
|
|
::soi::prettyprint::print(stream, c.second);
|
|
}
|
|
};
|
|
|
|
// Specialization for tuples
|
|
|
|
template <typename T, typename TChar, typename TCharTraits,
|
|
typename TDelimiters>
|
|
template <typename... Args>
|
|
struct pretty_print_container_helper<
|
|
T, TChar, TCharTraits, TDelimiters>::pretty_printer<std::tuple<Args...>> {
|
|
using ostream_type =
|
|
typename pretty_print_container_helper<T, TChar, TCharTraits,
|
|
TDelimiters>::ostream_type;
|
|
using element_type = std::tuple<Args...>;
|
|
|
|
template <std::size_t I> struct Int {};
|
|
|
|
static void pretty_print_body(const element_type &c, ostream_type &stream) {
|
|
tuple_pretty_print(c, stream, Int<0>());
|
|
}
|
|
|
|
static void tuple_pretty_print(const element_type &, ostream_type &,
|
|
Int<sizeof...(Args)>) {}
|
|
|
|
static void
|
|
tuple_pretty_print(const element_type &c, ostream_type &stream,
|
|
typename std::conditional<sizeof...(Args) != 0, Int<0>,
|
|
std::nullptr_t>::type) {
|
|
::soi::prettyprint::print(stream, std::get<0>(c));
|
|
tuple_pretty_print(c, stream, Int<1>());
|
|
}
|
|
|
|
template <std::size_t N>
|
|
static void tuple_pretty_print(const element_type &c, ostream_type &stream,
|
|
Int<N>) {
|
|
if (pretty_print_container_helper<T, TChar, TCharTraits,
|
|
TDelimiters>::delimiters_type::values
|
|
.delimiter != NULL)
|
|
::soi::prettyprint::print(
|
|
stream,
|
|
pretty_print_container_helper<T, TChar, TCharTraits,
|
|
TDelimiters>::delimiters_type::values
|
|
.delimiter);
|
|
|
|
::soi::prettyprint::print(stream, std::get<N>(c));
|
|
|
|
tuple_pretty_print(c, stream, Int<N + 1>());
|
|
}
|
|
};
|
|
|
|
// Pretty_Prints a pretty_print_container_helper to the specified stream.
|
|
|
|
template <typename T, typename TChar, typename TCharTraits,
|
|
typename TDelimiters>
|
|
inline std::basic_ostream<TChar, TCharTraits> &
|
|
pretty_print(std::basic_ostream<TChar, TCharTraits> &stream,
|
|
const pretty_print_container_helper<T, TChar, TCharTraits,
|
|
TDelimiters> &helper) {
|
|
helper(stream);
|
|
return stream;
|
|
}
|
|
|
|
// Basic is_container template; specialize to derive from std::true_type for all
|
|
// desired container types
|
|
|
|
template <typename T>
|
|
struct is_container
|
|
: public std::integral_constant<bool,
|
|
detail::has_const_iterator<T>::value &&
|
|
detail::has_begin_end<T>::beg_value &&
|
|
detail::has_begin_end<T>::end_value> {};
|
|
|
|
template <typename T, std::size_t N>
|
|
struct is_container<T[N]> : std::true_type {};
|
|
|
|
template <std::size_t N> struct is_container<char[N]> : std::false_type {};
|
|
|
|
template <typename T> struct is_container<std::valarray<T>> : std::true_type {};
|
|
|
|
template <typename T1, typename T2>
|
|
struct is_container<std::pair<T1, T2>> : std::true_type {};
|
|
|
|
template <typename... Args>
|
|
struct is_container<std::tuple<Args...>> : std::true_type {};
|
|
|
|
// Default delimiters
|
|
|
|
template <typename T> struct delimiters<T, char> {
|
|
static const delimiters_values<char> values;
|
|
};
|
|
template <typename T>
|
|
const delimiters_values<char> delimiters<T, char>::values = {"[", ", ", "]"};
|
|
template <typename T> struct delimiters<T, wchar_t> {
|
|
static const delimiters_values<wchar_t> values;
|
|
};
|
|
template <typename T>
|
|
const delimiters_values<wchar_t> delimiters<T, wchar_t>::values = {L"[", L", ",
|
|
L"]"};
|
|
|
|
// Delimiters for (multi)set and unordered_(multi)set
|
|
|
|
template <typename T, typename TComp, typename TAllocator>
|
|
struct delimiters<::std::set<T, TComp, TAllocator>, char> {
|
|
static const delimiters_values<char> values;
|
|
};
|
|
|
|
template <typename T, typename TComp, typename TAllocator>
|
|
const delimiters_values<char>
|
|
delimiters<::std::set<T, TComp, TAllocator>, char>::values = {"{", ", ",
|
|
"}"};
|
|
|
|
template <typename T, typename TComp, typename TAllocator>
|
|
struct delimiters<::std::set<T, TComp, TAllocator>, wchar_t> {
|
|
static const delimiters_values<wchar_t> values;
|
|
};
|
|
|
|
template <typename T, typename TComp, typename TAllocator>
|
|
const delimiters_values<wchar_t>
|
|
delimiters<::std::set<T, TComp, TAllocator>, wchar_t>::values = {
|
|
L"{", L", ", L"}"};
|
|
|
|
template <typename T, typename TComp, typename TAllocator>
|
|
struct delimiters<::std::multiset<T, TComp, TAllocator>, char> {
|
|
static const delimiters_values<char> values;
|
|
};
|
|
|
|
template <typename T, typename TComp, typename TAllocator>
|
|
const delimiters_values<char> delimiters<::std::multiset<T, TComp, TAllocator>,
|
|
char>::values = {"{", ", ", "}"};
|
|
|
|
template <typename T, typename TComp, typename TAllocator>
|
|
struct delimiters<::std::multiset<T, TComp, TAllocator>, wchar_t> {
|
|
static const delimiters_values<wchar_t> values;
|
|
};
|
|
|
|
template <typename T, typename TComp, typename TAllocator>
|
|
const delimiters_values<wchar_t>
|
|
delimiters<::std::multiset<T, TComp, TAllocator>, wchar_t>::values = {
|
|
L"{", L", ", L"}"};
|
|
|
|
template <typename T, typename THash, typename TEqual, typename TAllocator>
|
|
struct delimiters<::std::unordered_set<T, THash, TEqual, TAllocator>, char> {
|
|
static const delimiters_values<char> values;
|
|
};
|
|
|
|
template <typename T, typename THash, typename TEqual, typename TAllocator>
|
|
const delimiters_values<char> delimiters<
|
|
::std::unordered_set<T, THash, TEqual, TAllocator>, char>::values = {
|
|
"{", ", ", "}"};
|
|
|
|
template <typename T, typename THash, typename TEqual, typename TAllocator>
|
|
struct delimiters<::std::unordered_set<T, THash, TEqual, TAllocator>, wchar_t> {
|
|
static const delimiters_values<wchar_t> values;
|
|
};
|
|
|
|
template <typename T, typename THash, typename TEqual, typename TAllocator>
|
|
const delimiters_values<wchar_t> delimiters<
|
|
::std::unordered_set<T, THash, TEqual, TAllocator>, wchar_t>::values = {
|
|
L"{", L", ", L"}"};
|
|
|
|
template <typename T, typename THash, typename TEqual, typename TAllocator>
|
|
struct delimiters<::std::unordered_multiset<T, THash, TEqual, TAllocator>,
|
|
char> {
|
|
static const delimiters_values<char> values;
|
|
};
|
|
|
|
template <typename T, typename THash, typename TEqual, typename TAllocator>
|
|
const delimiters_values<char> delimiters<
|
|
::std::unordered_multiset<T, THash, TEqual, TAllocator>, char>::values = {
|
|
"{", ", ", "}"};
|
|
|
|
template <typename T, typename THash, typename TEqual, typename TAllocator>
|
|
struct delimiters<::std::unordered_multiset<T, THash, TEqual, TAllocator>,
|
|
wchar_t> {
|
|
static const delimiters_values<wchar_t> values;
|
|
};
|
|
|
|
template <typename T, typename THash, typename TEqual, typename TAllocator>
|
|
const delimiters_values<wchar_t>
|
|
delimiters<::std::unordered_multiset<T, THash, TEqual, TAllocator>,
|
|
wchar_t>::values = {L"{", L", ", L"}"};
|
|
|
|
// Delimiters for pair and tuple
|
|
|
|
template <typename T1, typename T2> struct delimiters<std::pair<T1, T2>, char> {
|
|
static const delimiters_values<char> values;
|
|
};
|
|
template <typename T1, typename T2>
|
|
const delimiters_values<char> delimiters<std::pair<T1, T2>, char>::values = {
|
|
"(", ", ", ")"};
|
|
template <typename T1, typename T2>
|
|
struct delimiters<::std::pair<T1, T2>, wchar_t> {
|
|
static const delimiters_values<wchar_t> values;
|
|
};
|
|
template <typename T1, typename T2>
|
|
const delimiters_values<wchar_t>
|
|
delimiters<::std::pair<T1, T2>, wchar_t>::values = {L"(", L", ", L")"};
|
|
|
|
template <typename... Args> struct delimiters<std::tuple<Args...>, char> {
|
|
static const delimiters_values<char> values;
|
|
};
|
|
template <typename... Args>
|
|
const delimiters_values<char> delimiters<std::tuple<Args...>, char>::values = {
|
|
"(", ", ", ")"};
|
|
template <typename... Args> struct delimiters<::std::tuple<Args...>, wchar_t> {
|
|
static const delimiters_values<wchar_t> values;
|
|
};
|
|
template <typename... Args>
|
|
const delimiters_values<wchar_t>
|
|
delimiters<::std::tuple<Args...>, wchar_t>::values = {L"(", L", ", L")"};
|
|
|
|
// Type-erasing helper class for easy use of custom delimiters.
|
|
// Requires TCharTraits = std::char_traits<TChar> and TChar = char or wchar_t,
|
|
// and MyDelims needs to be defined for TChar. Usage: "cout <<
|
|
// pretty_prettyprint::custom_delims<MyDelims>(x)".
|
|
|
|
struct custom_delims_base {
|
|
virtual ~custom_delims_base() {}
|
|
virtual std::ostream &stream(::std::ostream &) = 0;
|
|
virtual std::wostream &stream(::std::wostream &) = 0;
|
|
};
|
|
|
|
template <typename T, typename Delims>
|
|
struct custom_delims_wrapper : custom_delims_base {
|
|
custom_delims_wrapper(const T &t_) : t(t_) {}
|
|
|
|
std::ostream &stream(std::ostream &s) {
|
|
return pretty_print(
|
|
s,
|
|
pretty_print_container_helper<T, char, std::char_traits<char>, Delims>(
|
|
t));
|
|
}
|
|
|
|
std::wostream &stream(std::wostream &s) {
|
|
return pretty_print(
|
|
s, pretty_print_container_helper<T, wchar_t, std::char_traits<wchar_t>,
|
|
Delims>(t));
|
|
}
|
|
|
|
private:
|
|
const T &t;
|
|
};
|
|
|
|
template <typename Delims> struct custom_delims {
|
|
template <typename Container>
|
|
custom_delims(const Container &c)
|
|
: base(new custom_delims_wrapper<Container, Delims>(c)) {}
|
|
|
|
std::unique_ptr<custom_delims_base> base;
|
|
};
|
|
|
|
template <typename TChar, typename TCharTraits, typename Delims>
|
|
inline std::basic_ostream<TChar, TCharTraits> &
|
|
pretty_print(std::basic_ostream<TChar, TCharTraits> &s,
|
|
const custom_delims<Delims> &p) {
|
|
return p.base->stream(s);
|
|
}
|
|
|
|
// A wrapper for a C-style array given as pointer-plus-size.
|
|
// Usage: std::cout << pretty_pretty_print_array(arr, n) << std::endl;
|
|
|
|
template <typename T> struct array_wrapper_n {
|
|
typedef const T *const_iterator;
|
|
typedef T value_type;
|
|
|
|
array_wrapper_n(const T *const a, size_t n) : _array(a), _n(n) {}
|
|
inline const_iterator begin() const { return _array; }
|
|
inline const_iterator end() const { return _array + _n; }
|
|
|
|
private:
|
|
const T *const _array;
|
|
size_t _n;
|
|
};
|
|
|
|
// A wrapper for hash-table based containers that offer local iterators to each
|
|
// bucket. Usage: std::cout << bucket_pretty_print(m, 4) << std::endl;
|
|
// (Pretty_Prints bucket 5 of container m.)
|
|
|
|
template <typename T> struct bucket_pretty_print_wrapper {
|
|
typedef typename T::const_local_iterator const_iterator;
|
|
typedef typename T::size_type size_type;
|
|
|
|
const_iterator begin() const { return m_map.cbegin(n); }
|
|
|
|
const_iterator end() const { return m_map.cend(n); }
|
|
|
|
bucket_pretty_print_wrapper(const T &m, size_type bucket)
|
|
: m_map(m), n(bucket) {}
|
|
|
|
private:
|
|
const T &m_map;
|
|
const size_type n;
|
|
};
|
|
|
|
/*
|
|
// Global accessor functions for the convenience wrappers
|
|
|
|
template<typename T>
|
|
inline pretty_prettyprint::array_wrapper_n<T> pretty_pretty_print_array(const T
|
|
* const a, size_t n)
|
|
{
|
|
return pretty_prettyprint::array_wrapper_n<T>(a, n);
|
|
}
|
|
|
|
template <typename T> pretty_prettyprint::bucket_pretty_print_wrapper<T>
|
|
bucket_pretty_print(const T & m, typename T::size_type n)
|
|
{
|
|
return pretty_prettyprint::bucket_pretty_print_wrapper<T>(m, n);
|
|
}
|
|
|
|
|
|
// Main magic entry point: An overload snuck into namespace std.
|
|
// Can we do better?
|
|
|
|
*/
|
|
|
|
template <typename T, typename TChar, typename TCharTraits>
|
|
inline typename std::enable_if<::soi::prettyprint::is_container<T>::value,
|
|
std::basic_ostream<TChar, TCharTraits> &>::type
|
|
pretty_print(std::basic_ostream<TChar, TCharTraits> &stream,
|
|
const T &container) {
|
|
return ::soi::prettyprint::print(
|
|
stream,
|
|
::soi::prettyprint::pretty_print_container_helper<T, TChar, TCharTraits>(container));
|
|
}
|
|
|
|
}// namespace prettyprint
|
|
|
|
} // namespace soi
|
|
|
|
#endif // SOI_HEADER_PRETTY_PRETTY_PRINT
|