soi-header/include/bits/prettyprint.hpp

//          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_PRETTY_PRINT
#define SOI_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 {

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::print(stream, *it);

          if (++it == the_end)
            break;

          if (delimiters_type::values.delimiter != NULL)
            ::soi::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::print(stream, delimiters_type::values.prefix);

    pretty_printer<T>::pretty_print_body(container_, stream);

    if (delimiters_type::values.postfix != NULL)
      ::soi::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::print(stream, c.first);
    if (pretty_print_container_helper<T, TChar, TCharTraits,
                                      TDelimiters>::delimiters_type::values
            .delimiter != NULL)
      ::soi::print(
          stream,
          pretty_print_container_helper<T, TChar, TCharTraits,
                                        TDelimiters>::delimiters_type::values
              .delimiter);
    ::soi::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::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::print(
          stream,
          pretty_print_container_helper<T, TChar, TCharTraits,
                                        TDelimiters>::delimiters_type::values
              .delimiter);

    ::soi::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_pretty_print::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;
};

} // namespace soi

/*
// Global accessor functions for the convenience wrappers

template<typename T>
inline pretty_pretty_print::array_wrapper_n<T> pretty_pretty_print_array(const T
* const a, size_t n)
{
return pretty_pretty_print::array_wrapper_n<T>(a, n);
}

template <typename T> pretty_pretty_print::bucket_pretty_print_wrapper<T>
bucket_pretty_print(const T & m, typename T::size_type n)
{
return pretty_pretty_print::bucket_pretty_print_wrapper<T>(m, n);
}


// Main magic entry point: An overload snuck into namespace std.
// Can we do better?

*/

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));
}
} // namespace soi

#endif // SOI_PRETTY_PRETTY_PRINT