SOI
/
soi-header
103
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

fix pretty printer for recursive types

This commit is contained in:
Johannes Kapfhammer 2019-10-06 18:37:37 +02:00
parent 310d119ffb
commit 4d25fc25c4
5 changed files with 396 additions and 388 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
example.cpp
View File

@ -11,6 +11,9 @@ signed main() {
vector<int> pi{3,1,4,1,5,9,2,6}; vector<int> pi{3,1,4,1,5,9,2,6};
dbg(pi); dbg(pi);
dbg(vector<int>{3,1,4,1,5,9,2,6}); dbg(vector<int>{3,1,4,1,5,9,2,6});
dbg(pi); dbg(vector<pair<int, int>>{{3,1},{4,1}});
dbg(vector<pair<int, vector<string>>>{{3,{"hi"}},{4,{"hello", "world"}}});
dbg(set<int>{3,1,4});
dbg(map<int, string>{{3,"three"},{1,"one"}});
cout << "hi\n"; cout << "hi\n";
} }

132
include/bits/prettyprint.hpp
View File

@ -21,8 +21,12 @@
#include <utility> #include <utility>
#include <valarray> #include <valarray>
namespace pretty_print namespace soi {
{
template<typename T, typename TChar, typename TCharTraits>
std::basic_ostream<TChar, TCharTraits> &
print(std::basic_ostream<TChar, TCharTraits> & stream, const T& x);
namespace detail namespace detail
{ {
// SFINAE type trait to detect whether T::const_iterator exists. // SFINAE type trait to detect whether T::const_iterator exists.
@ -92,23 +96,23 @@ namespace pretty_print
}; };
// Functor to print containers. You can use this directly if you want // Functor to pretty_print containers. You can use this directly if you want
// to specificy a non-default delimiters type. The printing logic can // to specificy a non-default delimiters type. The pretty_printing logic can
// be customized by specializing the nested template. // be customized by specializing the nested template.
template <typename T, template <typename T,
typename TChar = char, typename TChar = char,
typename TCharTraits = ::std::char_traits<TChar>, typename TCharTraits = ::std::char_traits<TChar>,
typename TDelimiters = delimiters<T, TChar>> typename TDelimiters = delimiters<T, TChar>>
struct print_container_helper struct pretty_print_container_helper
{ {
using delimiters_type = TDelimiters; using delimiters_type = TDelimiters;
using ostream_type = std::basic_ostream<TChar, TCharTraits>; using ostream_type = std::basic_ostream<TChar, TCharTraits>;
template <typename U> template <typename U>
struct printer struct pretty_printer
{ {
static void print_body(const U & c, ostream_type & stream) static void pretty_print_body(const U & c, ostream_type & stream)
{ {
using std::begin; using std::begin;
using std::end; using std::end;
@ -120,30 +124,30 @@ namespace pretty_print
{ {
for ( ; ; ) for ( ; ; )
{ {
stream << *it; ::soi::print(stream, *it);
if (++it == the_end) break; if (++it == the_end) break;
if (delimiters_type::values.delimiter != NULL) if (delimiters_type::values.delimiter != NULL)
stream << delimiters_type::values.delimiter; ::soi::print(stream, delimiters_type::values.delimiter);
} }
} }
} }
}; };
print_container_helper(const T & container) pretty_print_container_helper(const T & container)
: container_(container) : container_(container)
{ } { }
inline void operator()(ostream_type & stream) const inline void operator()(ostream_type & stream) const
{ {
if (delimiters_type::values.prefix != NULL) if (delimiters_type::values.prefix != NULL)
stream << delimiters_type::values.prefix; ::soi::print(stream, delimiters_type::values.prefix);
printer<T>::print_body(container_, stream); pretty_printer<T>::pretty_print_body(container_, stream);
if (delimiters_type::values.postfix != NULL) if (delimiters_type::values.postfix != NULL)
stream << delimiters_type::values.postfix; ::soi::print(stream, delimiters_type::values.postfix);
} }
private: private:
@ -154,16 +158,16 @@ namespace pretty_print
template <typename T, typename TChar, typename TCharTraits, typename TDelimiters> template <typename T, typename TChar, typename TCharTraits, typename TDelimiters>
template <typename T1, typename T2> template <typename T1, typename T2>
struct print_container_helper<T, TChar, TCharTraits, TDelimiters>::printer<std::pair<T1, T2>> struct pretty_print_container_helper<T, TChar, TCharTraits, TDelimiters>::pretty_printer<std::pair<T1, T2>>
{ {
using ostream_type = typename print_container_helper<T, TChar, TCharTraits, TDelimiters>::ostream_type; using ostream_type = typename pretty_print_container_helper<T, TChar, TCharTraits, TDelimiters>::ostream_type;
static void print_body(const std::pair<T1, T2> & c, ostream_type & stream) static void pretty_print_body(const std::pair<T1, T2> & c, ostream_type & stream)
{ {
stream << c.first; ::soi::print(stream, c.first);
if (print_container_helper<T, TChar, TCharTraits, TDelimiters>::delimiters_type::values.delimiter != NULL) if (pretty_print_container_helper<T, TChar, TCharTraits, TDelimiters>::delimiters_type::values.delimiter != NULL)
stream << print_container_helper<T, TChar, TCharTraits, TDelimiters>::delimiters_type::values.delimiter; ::soi::print(stream, pretty_print_container_helper<T, TChar, TCharTraits, TDelimiters>::delimiters_type::values.delimiter);
stream << c.second; ::soi::print(stream, c.second);
} }
}; };
@ -171,47 +175,47 @@ namespace pretty_print
template <typename T, typename TChar, typename TCharTraits, typename TDelimiters> template <typename T, typename TChar, typename TCharTraits, typename TDelimiters>
template <typename ...Args> template <typename ...Args>
struct print_container_helper<T, TChar, TCharTraits, TDelimiters>::printer<std::tuple<Args...>> struct pretty_print_container_helper<T, TChar, TCharTraits, TDelimiters>::pretty_printer<std::tuple<Args...>>
{ {
using ostream_type = typename print_container_helper<T, TChar, TCharTraits, TDelimiters>::ostream_type; using ostream_type = typename pretty_print_container_helper<T, TChar, TCharTraits, TDelimiters>::ostream_type;
using element_type = std::tuple<Args...>; using element_type = std::tuple<Args...>;
template <std::size_t I> struct Int { }; template <std::size_t I> struct Int { };
static void print_body(const element_type & c, ostream_type & stream) static void pretty_print_body(const element_type & c, ostream_type & stream)
{ {
tuple_print(c, stream, Int<0>()); tuple_pretty_print(c, stream, Int<0>());
} }
static void tuple_print(const element_type &, ostream_type &, Int<sizeof...(Args)>) static void tuple_pretty_print(const element_type &, ostream_type &, Int<sizeof...(Args)>)
{ {
} }
static void tuple_print(const element_type & c, ostream_type & stream, static void tuple_pretty_print(const element_type & c, ostream_type & stream,
typename std::conditional<sizeof...(Args) != 0, Int<0>, std::nullptr_t>::type) typename std::conditional<sizeof...(Args) != 0, Int<0>, std::nullptr_t>::type)
{ {
stream << std::get<0>(c); ::soi::print(stream, std::get<0>(c));
tuple_print(c, stream, Int<1>()); tuple_pretty_print(c, stream, Int<1>());
} }
template <std::size_t N> template <std::size_t N>
static void tuple_print(const element_type & c, ostream_type & stream, Int<N>) static void tuple_pretty_print(const element_type & c, ostream_type & stream, Int<N>)
{ {
if (print_container_helper<T, TChar, TCharTraits, TDelimiters>::delimiters_type::values.delimiter != NULL) if (pretty_print_container_helper<T, TChar, TCharTraits, TDelimiters>::delimiters_type::values.delimiter != NULL)
stream << print_container_helper<T, TChar, TCharTraits, TDelimiters>::delimiters_type::values.delimiter; ::soi::print(stream, pretty_print_container_helper<T, TChar, TCharTraits, TDelimiters>::delimiters_type::values.delimiter);
stream << std::get<N>(c); ::soi::print(stream, std::get<N>(c));
tuple_print(c, stream, Int<N + 1>()); tuple_pretty_print(c, stream, Int<N + 1>());
} }
}; };
// Prints a print_container_helper to the specified stream. // Pretty_Prints a pretty_print_container_helper to the specified stream.
template<typename T, typename TChar, typename TCharTraits, typename TDelimiters> template<typename T, typename TChar, typename TCharTraits, typename TDelimiters>
inline std::basic_ostream<TChar, TCharTraits> & operator<<( inline std::basic_ostream<TChar, TCharTraits> & pretty_print(
std::basic_ostream<TChar, TCharTraits> & stream, std::basic_ostream<TChar, TCharTraits> & stream,
const print_container_helper<T, TChar, TCharTraits, TDelimiters> & helper) const pretty_print_container_helper<T, TChar, TCharTraits, TDelimiters> & helper)
{ {
helper(stream); helper(stream);
return stream; return stream;
@ -316,7 +320,7 @@ namespace pretty_print
// Type-erasing helper class for easy use of custom delimiters. // 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. // Requires TCharTraits = std::char_traits<TChar> and TChar = char or wchar_t, and MyDelims needs to be defined for TChar.
// Usage: "cout << pretty_print::custom_delims<MyDelims>(x)". // Usage: "cout << pretty_pretty_print::custom_delims<MyDelims>(x)".
struct custom_delims_base struct custom_delims_base
{ {
@ -332,12 +336,12 @@ namespace pretty_print
std::ostream & stream(std::ostream & s) std::ostream & stream(std::ostream & s)
{ {
return s << print_container_helper<T, char, std::char_traits<char>, Delims>(t); return pretty_print(s, pretty_print_container_helper<T, char, std::char_traits<char>, Delims>(t));
} }
std::wostream & stream(std::wostream & s) std::wostream & stream(std::wostream & s)
{ {
return s << print_container_helper<T, wchar_t, std::char_traits<wchar_t>, Delims>(t); return pretty_print(s, pretty_print_container_helper<T, wchar_t, std::char_traits<wchar_t>, Delims>(t));
} }
private: private:
@ -354,14 +358,14 @@ namespace pretty_print
}; };
template <typename TChar, typename TCharTraits, typename Delims> template <typename TChar, typename TCharTraits, typename Delims>
inline std::basic_ostream<TChar, TCharTraits> & operator<<(std::basic_ostream<TChar, TCharTraits> & s, const custom_delims<Delims> & p) inline std::basic_ostream<TChar, TCharTraits> & pretty_print(std::basic_ostream<TChar, TCharTraits> & s, const custom_delims<Delims> & p)
{ {
return p.base->stream(s); return p.base->stream(s);
} }
// A wrapper for a C-style array given as pointer-plus-size. // A wrapper for a C-style array given as pointer-plus-size.
// Usage: std::cout << pretty_print_array(arr, n) << std::endl; // Usage: std::cout << pretty_pretty_print_array(arr, n) << std::endl;
template<typename T> template<typename T>
struct array_wrapper_n struct array_wrapper_n
@ -380,10 +384,10 @@ namespace pretty_print
// A wrapper for hash-table based containers that offer local iterators to each bucket. // A wrapper for hash-table based containers that offer local iterators to each bucket.
// Usage: std::cout << bucket_print(m, 4) << std::endl; (Prints bucket 5 of container m.) // Usage: std::cout << bucket_pretty_print(m, 4) << std::endl; (Pretty_Prints bucket 5 of container m.)
template <typename T> template <typename T>
struct bucket_print_wrapper struct bucket_pretty_print_wrapper
{ {
typedef typename T::const_local_iterator const_iterator; typedef typename T::const_local_iterator const_iterator;
typedef typename T::size_type size_type; typedef typename T::size_type size_type;
@ -398,47 +402,49 @@ namespace pretty_print
return m_map.cend(n); return m_map.cend(n);
} }
bucket_print_wrapper(const T & m, size_type bucket) : m_map(m), n(bucket) { } bucket_pretty_print_wrapper(const T & m, size_type bucket) : m_map(m), n(bucket) { }
private: private:
const T & m_map; const T & m_map;
const size_type n; const size_type n;
}; };
} // namespace pretty_print } // namespace soi
/* /*
// Global accessor functions for the convenience wrappers // Global accessor functions for the convenience wrappers
template<typename T> template<typename T>
inline pretty_print::array_wrapper_n<T> pretty_print_array(const T * const a, size_t n) inline pretty_pretty_print::array_wrapper_n<T> pretty_pretty_print_array(const T * const a, size_t n)
{ {
return pretty_print::array_wrapper_n<T>(a, n); return pretty_pretty_print::array_wrapper_n<T>(a, n);
} }
template <typename T> pretty_print::bucket_print_wrapper<T> template <typename T> pretty_pretty_print::bucket_pretty_print_wrapper<T>
bucket_print(const T & m, typename T::size_type n) bucket_pretty_print(const T & m, typename T::size_type n)
{ {
return pretty_print::bucket_print_wrapper<T>(m, n); return pretty_pretty_print::bucket_pretty_print_wrapper<T>(m, n);
} }
// Main magic entry point: An overload snuck into namespace std. // Main magic entry point: An overload snuck into namespace std.
// Can we do better? // Can we do better?
namespace std
{
// Prints a container to the stream using default delimiters
template<typename T, typename TChar, typename TCharTraits>
inline typename enable_if< ::pretty_print::is_container<T>::value,
basic_ostream<TChar, TCharTraits> &>::type
operator<<(basic_ostream<TChar, TCharTraits> & stream, const T & container)
{
return stream << ::pretty_print::print_container_helper<T, TChar, TCharTraits>(container);
}
}
*/ */
#endif // SOI_PRETTY_PRINT namespace soi
{
// Pretty_Prints a container to the stream using default delimiters
template<typename T, typename TChar, typename TCharTraits>
inline typename std::enable_if< ::soi::is_container<T>::value,
std::basic_ostream<TChar, TCharTraits> &>::type
pretty_print(std::basic_ostream<TChar, TCharTraits> & stream, const T & container)
{
return ::soi::print(stream, ::soi::pretty_print_container_helper<T, TChar, TCharTraits>(container));
}
}
#endif // SOI_PRETTY_PRETTY_PRINT

10
include/bits/soi-dbg.hpp
View File

@ -23,7 +23,7 @@
#include "soi-pretty.hpp" #include "soi-pretty.hpp"
namespace soi_h { namespace soi {
namespace detail { namespace detail {
@ -102,7 +102,7 @@ CONSTEXPR14_TN
static_string static_string
type_name() type_name()
{ {
const int k = sizeof("constexpr soi_h::detail:: T =")/sizeof(char); const int k = sizeof("constexpr soi::detail:: T")/sizeof(char);
#ifdef __clang__ #ifdef __clang__
static_string p = __PRETTY_FUNCTION__; static_string p = __PRETTY_FUNCTION__;
return static_string(p.data() + 31 + k, p.size() - 31 - k - 1); return static_string(p.data() + 31 + k, p.size() - 31 - k - 1);
@ -215,7 +215,7 @@ T&& dbg_print(T&& value,
char const* expression) { char const* expression) {
const T& ref = value; const T& ref = value;
std::stringstream value_buffer; // avoid nesting of dbg macros within print functinos std::stringstream value_buffer; // avoid nesting of dbg macros within print functinos
soi_h::pretty_print(value_buffer, ref); soi::print(value_buffer, ref);
std::cerr << ANSI_DEBUG std::cerr << ANSI_DEBUG
<< "[" << file << ":" << line << "[" << file << ":" << line
@ -257,8 +257,8 @@ T&& identity(T&& t) {
#define dbg(...) dbg_macro::identity(__VA_ARGS__) #define dbg(...) dbg_macro::identity(__VA_ARGS__)
#else #else
#define dbg(...) \ #define dbg(...) \
soi_h::detail::dbg_print((__VA_ARGS__), \ soi::detail::dbg_print((__VA_ARGS__), \
soi_h::detail::sanitized_type_name<decltype(__VA_ARGS__)>(), \ soi::detail::sanitized_type_name<decltype(__VA_ARGS__)>(), \
__FILE__, \ __FILE__, \
__LINE__, \ __LINE__, \
__func__, \ __func__, \

19
include/bits/soi-pretty.hpp
View File

@ -3,7 +3,7 @@
// (See accompanying file LICENSE_1_0.txt or copy at // (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt) // http://www.boost.org/LICENSE_1_0.txt)
// //
// pretty printing with c++ // pretty pretty_printing with c++
// //
#ifndef SOI_PRETTY #ifndef SOI_PRETTY
@ -11,14 +11,7 @@
#include "prettyprint.hpp" #include "prettyprint.hpp"
namespace soi_h { namespace soi {
template<typename T, typename TChar, typename TCharTraits>
inline typename std::enable_if< ::pretty_print::is_container<T>::value,
std::basic_ostream<TChar, TCharTraits> &>::type
pretty_print(std::basic_ostream<TChar, TCharTraits> & stream, const T & container) {
return stream << ::pretty_print::print_container_helper<T, TChar, TCharTraits>(container);
}
template<typename TChar, typename TCharTraits> template<typename TChar, typename TCharTraits>
std::basic_ostream<TChar, TCharTraits> & std::basic_ostream<TChar, TCharTraits> &
@ -65,12 +58,18 @@ pretty_print(std::basic_ostream<TChar, TCharTraits> & stream, char c) {
} }
template<typename T, typename TChar, typename TCharTraits> template<typename T, typename TChar, typename TCharTraits>
inline typename std::enable_if< !::pretty_print::is_container<T>::value, inline typename std::enable_if< !::soi::is_container<T>::value,
std::basic_ostream<TChar, TCharTraits> &>::type std::basic_ostream<TChar, TCharTraits> &>::type
pretty_print(std::basic_ostream<TChar, TCharTraits> & stream, const T& x) { pretty_print(std::basic_ostream<TChar, TCharTraits> & stream, const T& x) {
return stream << x; return stream << x;
} }
template<typename T, typename TChar, typename TCharTraits>
std::basic_ostream<TChar, TCharTraits> &
print(std::basic_ostream<TChar, TCharTraits> & stream, const T& x) {
return pretty_print(stream, x);
}
} }
#endif // SOI_PRETTY #endif // SOI_PRETTY

14
include/soi
View File

@ -8,7 +8,7 @@
#include <fstream> #include <fstream>
#include "bits/soi-dbg.hpp" #include "bits/soi-dbg.hpp"
namespace soi_h { namespace soi {
void check_for_eof() { void check_for_eof() {
if (!(std::cin >> std::ws).eof()) if (!(std::cin >> std::ws).eof())
@ -52,11 +52,11 @@ void initialize_debug() {
std::atexit(noninteractive_check_eof) != 0) { std::atexit(noninteractive_check_eof) != 0) {
std::cerr << "WARNING: soi.h -- registration of sanity check at exit failed\n"; std::cerr << "WARNING: soi.h -- registration of sanity check at exit failed\n";
} }
soi_h::detail::dbg_init(); soi::detail::dbg_init();
} }
struct soi_h_initializer { struct soi_initializer {
soi_h_initializer(bool release) { soi_initializer(bool release) {
if (release) { if (release) {
std::ios::sync_with_stdio(false); std::ios::sync_with_stdio(false);
std::cin.tie(0); std::cin.tie(0);
@ -67,12 +67,12 @@ struct soi_h_initializer {
}; };
#ifdef SOI_RELEASE #ifdef SOI_RELEASE
soi_h_initializer soi_h_initializer_{true}; soi_initializer soi_initializer_{true};
#else #else
soi_h_initializer soi_h_initializer_{false}; soi_initializer soi_initializer_{false};
#endif #endif
} // end namespace soi_h } // end namespace soi
#include "bits/soi-deprecate.hpp" #include "bits/soi-deprecate.hpp"