run clang-format

example.cpp

@@ -1,7 +1,7 @@
 // compile-command: "g++ -Iinclude -D_GLIBCXX_DEBUG -fsanitize=address,undefined -g3 -ggdb3 -std=c++17 example.cpp -o example && SOI_H_COLOR=1 SOI_H_EOFCHECK=1 ./example <<< ''"
 #include <soi>
 
-signed main() {  
+signed main() {
   dbg("hi");
   string s="world";
   dbg(s);
@@ -11,6 +11,9 @@ signed main() {
   vector<int> pi{3,1,4,1,5,9,2,6};
   dbg(pi);
   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";
 }

include/bits/include-all.hpp

@@ -15,6 +15,7 @@
 #include <iostream>
 #include <iterator>
 #include <list>
+#include <map>
 #include <memory>
 #include <ostream>
 #include <queue>

include/bits/prettyprint.hpp

@@ -21,424 +21,476 @@
 #include <utility>
 #include <valarray>
 
-namespace pretty_print
-{
-    namespace detail
-    {
-        // SFINAE type trait to detect whether T::const_iterator exists.
+namespace soi {
 
-        struct sfinae_base
-        {
-            using yes = char;
-            using no  = yes[2];
-        };
+template <typename T, typename TChar, typename TCharTraits>
+std::basic_ostream<TChar, TCharTraits> &
+print(std::basic_ostream<TChar, TCharTraits> &stream, const T &x);
 
-        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;
-        };
+namespace detail {
+// SFINAE type trait to detect whether T::const_iterator exists.
 
-        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 *);
+struct sfinae_base {
+  using yes = char;
+  using no = yes[2];
+};
 
-            template <typename C> static no & f(...);
+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(...);
 
-            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*);
+public:
+  static const bool value = sizeof(test<T>(nullptr)) == sizeof(yes);
+  using type = T;
+};
 
-            template <typename C> static no & g(...);
+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 *);
 
-        public:
-            static bool const beg_value = sizeof(f<T>(nullptr)) == sizeof(yes);
-            static bool const end_value = sizeof(g<T>(nullptr)) == sizeof(yes);
-        };
+  template <typename C> static no &f(...);
 
-    }  // namespace detail
+  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(...);
 
-    // Holds the delimiter values for a specific character type
+public:
+  static bool const beg_value = sizeof(f<T>(nullptr)) == sizeof(yes);
+  static bool const end_value = sizeof(g<T>(nullptr)) == sizeof(yes);
+};
 
-    template <typename TChar>
-    struct delimiters_values
-    {
-        using char_type = TChar;
-        const char_type * prefix;
-        const char_type * delimiter;
-        const char_type * postfix;
-    };
+} // namespace detail
 
+// Holds the delimiter values for a specific character type
 
-    // Defines the delimiter values for a specific container and character type
+template <typename TChar> struct delimiters_values {
+  using char_type = TChar;
+  const char_type *prefix;
+  const char_type *delimiter;
+  const char_type *postfix;
+};
 
-    template <typename T, typename TChar>
-    struct delimiters
-    {
-        using type = delimiters_values<TChar>;
-        static const type values;
-    };
+// 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 print containers. You can use this directly if you want
-    // to specificy a non-default delimiters type. The printing logic can
-    // be customized by specializing the nested template.
+// 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 print_container_helper
-    {
-        using delimiters_type = TDelimiters;
-        using ostream_type = std::basic_ostream<TChar, TCharTraits>;
+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 printer
-        {
-            static void print_body(const U & c, ostream_type & stream)
-            {
-                using std::begin;
-                using std::end;
+  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);
+      auto it = begin(c);
+      const auto the_end = end(c);
 
-                if (it != the_end)
-                {
-                    for ( ; ; )
-                    {
-                        stream << *it;
+      if (it != the_end) {
+        for (;;) {
+          ::soi::print(stream, *it);
 
-                    if (++it == the_end) break;
+          if (++it == the_end)
+            break;
 
-                    if (delimiters_type::values.delimiter != NULL)
-                        stream << delimiters_type::values.delimiter;
-                    }
-                }
-            }
-        };
-
-        print_container_helper(const T & container)
-        : container_(container)
-        { }
-
-        inline void operator()(ostream_type & stream) const
-        {
-            if (delimiters_type::values.prefix != NULL)
-                stream << delimiters_type::values.prefix;
-
-            printer<T>::print_body(container_, stream);
-
-            if (delimiters_type::values.postfix != NULL)
-                stream << delimiters_type::values.postfix;
+          if (delimiters_type::values.delimiter != NULL)
+            ::soi::print(stream, delimiters_type::values.delimiter);
         }
-
-    private:
-        const T & container_;
-    };
-
-    // Specialization for pairs
-
-    template <typename T, typename TChar, typename TCharTraits, typename TDelimiters>
-    template <typename T1, typename T2>
-    struct print_container_helper<T, TChar, TCharTraits, TDelimiters>::printer<std::pair<T1, T2>>
-    {
-        using ostream_type = typename print_container_helper<T, TChar, TCharTraits, TDelimiters>::ostream_type;
-
-        static void print_body(const std::pair<T1, T2> & c, ostream_type & stream)
-        {
-            stream << c.first;
-            if (print_container_helper<T, TChar, TCharTraits, TDelimiters>::delimiters_type::values.delimiter != NULL)
-                stream << print_container_helper<T, TChar, TCharTraits, TDelimiters>::delimiters_type::values.delimiter;
-            stream << c.second;
-        }
-    };
-
-    // Specialization for tuples
-
-    template <typename T, typename TChar, typename TCharTraits, typename TDelimiters>
-    template <typename ...Args>
-    struct print_container_helper<T, TChar, TCharTraits, TDelimiters>::printer<std::tuple<Args...>>
-    {
-        using ostream_type = typename print_container_helper<T, TChar, TCharTraits, TDelimiters>::ostream_type;
-        using element_type = std::tuple<Args...>;
-
-        template <std::size_t I> struct Int { };
-
-        static void print_body(const element_type & c, ostream_type & stream)
-        {
-            tuple_print(c, stream, Int<0>());
-        }
-
-        static void tuple_print(const element_type &, ostream_type &, Int<sizeof...(Args)>)
-        {
-        }
-
-        static void tuple_print(const element_type & c, ostream_type & stream,
-                                typename std::conditional<sizeof...(Args) != 0, Int<0>, std::nullptr_t>::type)
-        {
-            stream << std::get<0>(c);
-            tuple_print(c, stream, Int<1>());
-        }
-
-        template <std::size_t N>
-        static void tuple_print(const element_type & c, ostream_type & stream, Int<N>)
-        {
-            if (print_container_helper<T, TChar, TCharTraits, TDelimiters>::delimiters_type::values.delimiter != NULL)
-                stream << print_container_helper<T, TChar, TCharTraits, TDelimiters>::delimiters_type::values.delimiter;
-
-            stream << std::get<N>(c);
-
-            tuple_print(c, stream, Int<N + 1>());
-        }
-    };
-
-    // Prints a print_container_helper to the specified stream.
-
-    template<typename T, typename TChar, typename TCharTraits, typename TDelimiters>
-    inline std::basic_ostream<TChar, TCharTraits> & operator<<(
-        std::basic_ostream<TChar, TCharTraits> & stream,
-        const print_container_helper<T, TChar, TCharTraits, TDelimiters> & helper)
-    {
-        helper(stream);
-        return stream;
+      }
     }
+  };
 
+  pretty_print_container_helper(const T &container) : container_(container) {}
 
-    // Basic is_container template; specialize to derive from std::true_type for all desired container types
+  inline void operator()(ostream_type &stream) const {
+    if (delimiters_type::values.prefix != NULL)
+      ::soi::print(stream, delimiters_type::values.prefix);
 
-    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> { };
+    pretty_printer<T>::pretty_print_body(container_, stream);
 
-    template <typename T, std::size_t N>
-    struct is_container<T[N]> : std::true_type { };
+    if (delimiters_type::values.postfix != NULL)
+      ::soi::print(stream, delimiters_type::values.postfix);
+  }
 
-    template <std::size_t N>
-    struct is_container<char[N]> : std::false_type { };
+private:
+  const T &container_;
+};
 
-    template <typename T>
-    struct is_container<std::valarray<T>> : std::true_type { };
+// Specialization for pairs
 
-    template <typename T1, typename T2>
-    struct is_container<std::pair<T1, T2>> : std::true_type { };
+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;
 
-    template <typename ...Args>
-    struct is_container<std::tuple<Args...>> : std::true_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
 
-    // Default delimiters
+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 <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"]" };
+  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>());
+  }
 
-    // Delimiters for (multi)set and unordered_(multi)set
+  static void tuple_pretty_print(const element_type &, ostream_type &,
+                                 Int<sizeof...(Args)>) {}
 
-    template <typename T, typename TComp, typename TAllocator>
-    struct delimiters< ::std::set<T, TComp, TAllocator>, char> { static const delimiters_values<char> values; };
+  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 <typename T, typename TComp, typename TAllocator>
-    const delimiters_values<char> delimiters< ::std::set<T, TComp, TAllocator>, char>::values = { "{", ", ", "}" };
+  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);
 
-    template <typename T, typename TComp, typename TAllocator>
-    struct delimiters< ::std::set<T, TComp, TAllocator>, wchar_t> { static const delimiters_values<wchar_t> values; };
+    ::soi::print(stream, std::get<N>(c));
 
-    template <typename T, typename TComp, typename TAllocator>
-    const delimiters_values<wchar_t> delimiters< ::std::set<T, TComp, TAllocator>, wchar_t>::values = { L"{", L", ", L"}" };
+    tuple_pretty_print(c, stream, Int<N + 1>());
+  }
+};
 
-    template <typename T, typename TComp, typename TAllocator>
-    struct delimiters< ::std::multiset<T, TComp, TAllocator>, char> { static const delimiters_values<char> values; };
+// Pretty_Prints a pretty_print_container_helper to the specified stream.
 
-    template <typename T, typename TComp, typename TAllocator>
-    const delimiters_values<char> delimiters< ::std::multiset<T, TComp, TAllocator>, char>::values = { "{", ", ", "}" };
+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;
+}
 
-    template <typename T, typename TComp, typename TAllocator>
-    struct delimiters< ::std::multiset<T, TComp, TAllocator>, wchar_t> { static const delimiters_values<wchar_t> values; };
+// Basic is_container template; specialize to derive from std::true_type for all
+// desired container types
 
-    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>
+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, 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, std::size_t N>
+struct is_container<T[N]> : std::true_type {};
 
-    template <typename T, typename THash, typename TEqual, typename TAllocator>
-    const delimiters_values<char> delimiters< ::std::unordered_set<T, THash, TEqual, TAllocator>, char>::values = { "{", ", ", "}" };
+template <std::size_t N> struct is_container<char[N]> : std::false_type {};
 
-    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> struct is_container<std::valarray<T>> : std::true_type {};
 
-    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 T1, typename T2>
+struct is_container<std::pair<T1, T2>> : std::true_type {};
 
-    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... Args>
+struct is_container<std::tuple<Args...>> : std::true_type {};
 
-    template <typename T, typename THash, typename TEqual, typename TAllocator>
-    const delimiters_values<char> delimiters< ::std::unordered_multiset<T, THash, TEqual, TAllocator>, char>::values = { "{", ", ", "}" };
+// Default delimiters
 
-    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> 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"]"};
 
-    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 (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;
+};
 
-    // Delimiters for pair and tuple
+template <typename T, typename TComp, typename TAllocator>
+const delimiters_values<char>
+    delimiters<::std::set<T, TComp, TAllocator>, char>::values = {"{", ", ",
+                                                                  "}"};
 
-    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 T, typename TComp, typename TAllocator>
+struct delimiters<::std::set<T, TComp, TAllocator>, wchar_t> {
+  static const delimiters_values<wchar_t> values;
+};
 
-    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")" };
+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;
+};
 
-    // 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_print::custom_delims<MyDelims>(x)".
+template <typename T, typename TComp, typename TAllocator>
+const delimiters_values<char> delimiters<::std::multiset<T, TComp, TAllocator>,
+                                         char>::values = {"{", ", ", "}"};
 
-    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 TComp, typename TAllocator>
+struct delimiters<::std::multiset<T, TComp, TAllocator>, wchar_t> {
+  static const delimiters_values<wchar_t> values;
+};
 
-    template <typename T, typename Delims>
-    struct custom_delims_wrapper : custom_delims_base
-    {
-        custom_delims_wrapper(const T & t_) : t(t_) { }
+template <typename T, typename TComp, typename TAllocator>
+const delimiters_values<wchar_t>
+    delimiters<::std::multiset<T, TComp, TAllocator>, wchar_t>::values = {
+        L"{", L", ", L"}"};
 
-        std::ostream & stream(std::ostream & s)
-        {
-            return s << print_container_helper<T, char, std::char_traits<char>, Delims>(t);
-        }
+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;
+};
 
-        std::wostream & stream(std::wostream & s)
-        {
-            return s << print_container_helper<T, wchar_t, std::char_traits<wchar_t>, Delims>(t);
-        }
+template <typename T, typename THash, typename TEqual, typename TAllocator>
+const delimiters_values<char> delimiters<
+    ::std::unordered_set<T, THash, TEqual, TAllocator>, char>::values = {
+    "{", ", ", "}"};
 
-    private:
-        const T & t;
-    };
+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 Delims>
-    struct custom_delims
-    {
-        template <typename Container>
-        custom_delims(const Container & c) : base(new custom_delims_wrapper<Container, Delims>(c)) { }
+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"}"};
 
-        std::unique_ptr<custom_delims_base> base;
-    };
+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 TChar, typename TCharTraits, typename Delims>
-    inline std::basic_ostream<TChar, TCharTraits> & operator<<(std::basic_ostream<TChar, TCharTraits> & s, const custom_delims<Delims> & p)
-    {
-        return p.base->stream(s);
-    }
+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;
+};
 
-    // A wrapper for a C-style array given as pointer-plus-size.
-    // Usage: std::cout << pretty_print_array(arr, n) << std::endl;
+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"}"};
 
-    template<typename T>
-    struct array_wrapper_n
-    {
-        typedef const T * const_iterator;
-        typedef T value_type;
+// Delimiters for pair and tuple
 
-        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; }
+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")"};
 
-    private:
-        const T * const _array;
-        size_t _n;
-    };
+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)".
 
-    // 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.)
+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>
-    struct bucket_print_wrapper
-    {
-        typedef typename T::const_local_iterator const_iterator;
-        typedef typename T::size_type size_type;
+template <typename T, typename Delims>
+struct custom_delims_wrapper : custom_delims_base {
+  custom_delims_wrapper(const T &t_) : t(t_) {}
 
-        const_iterator begin() const
-        {
-            return m_map.cbegin(n);
-        }
+  std::ostream &stream(std::ostream &s) {
+    return pretty_print(
+        s,
+        pretty_print_container_helper<T, char, std::char_traits<char>, Delims>(
+            t));
+  }
 
-        const_iterator end() const
-        {
-            return m_map.cend(n);
-        }
+  std::wostream &stream(std::wostream &s) {
+    return pretty_print(
+        s, pretty_print_container_helper<T, wchar_t, std::char_traits<wchar_t>,
+                                         Delims>(t));
+  }
 
-        bucket_print_wrapper(const T & m, size_type bucket) : m_map(m), n(bucket) { }
+private:
+  const T &t;
+};
 
-    private:
-        const T & m_map;
-        const size_type n;
-    };
+template <typename Delims> struct custom_delims {
+  template <typename Container>
+  custom_delims(const Container &c)
+      : base(new custom_delims_wrapper<Container, Delims>(c)) {}
 
-}   // namespace pretty_print
+  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_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>
-bucket_print(const T & m, typename T::size_type 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_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.
 // 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));
+}
+} // namespace soi
+
+#endif // SOI_PRETTY_PRETTY_PRINT

include/bits/soi-dbg.hpp

@@ -11,11 +11,11 @@
 #define SOI_DBG
 
 #include <cstddef>
-#include <stdexcept>
 #include <cstring>
-#include <ostream>
 #include <iostream>
+#include <ostream>
 #include <sstream>
+#include <stdexcept>
 
 #if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
 #include <unistd.h>
@@ -23,7 +23,7 @@
 
 #include "soi-pretty.hpp"
 
-namespace soi_h {
+namespace soi {
 
 namespace detail {
 
@@ -31,113 +31,99 @@ namespace detail {
 // detecting the type name: https://stackoverflow.com/a/20170989
 
 #ifndef _MSC_VER
-#  if __cplusplus < 201103
-#    define CONSTEXPR11_TN
-#    define CONSTEXPR14_TN
-#    define NOEXCEPT_TN
-#  elif __cplusplus < 201402
-#    define CONSTEXPR11_TN constexpr
-#    define CONSTEXPR14_TN
-#    define NOEXCEPT_TN noexcept
-#  else
-#    define CONSTEXPR11_TN constexpr
-#    define CONSTEXPR14_TN constexpr
-#    define NOEXCEPT_TN noexcept
-#  endif
-#else  // _MSC_VER
-#  if _MSC_VER < 1900
-#    define CONSTEXPR11_TN
-#    define CONSTEXPR14_TN
-#    define NOEXCEPT_TN
-#  elif _MSC_VER < 2000
-#    define CONSTEXPR11_TN constexpr
-#    define CONSTEXPR14_TN
-#    define NOEXCEPT_TN noexcept
-#  else
-#    define CONSTEXPR11_TN constexpr
-#    define CONSTEXPR14_TN constexpr
-#    define NOEXCEPT_TN noexcept
-#  endif
-#endif  // _MSC_VER
+#if __cplusplus < 201103
+#define CONSTEXPR11_TN
+#define CONSTEXPR14_TN
+#define NOEXCEPT_TN
+#elif __cplusplus < 201402
+#define CONSTEXPR11_TN constexpr
+#define CONSTEXPR14_TN
+#define NOEXCEPT_TN noexcept
+#else
+#define CONSTEXPR11_TN constexpr
+#define CONSTEXPR14_TN constexpr
+#define NOEXCEPT_TN noexcept
+#endif
+#else // _MSC_VER
+#if _MSC_VER < 1900
+#define CONSTEXPR11_TN
+#define CONSTEXPR14_TN
+#define NOEXCEPT_TN
+#elif _MSC_VER < 2000
+#define CONSTEXPR11_TN constexpr
+#define CONSTEXPR14_TN
+#define NOEXCEPT_TN noexcept
+#else
+#define CONSTEXPR11_TN constexpr
+#define CONSTEXPR14_TN constexpr
+#define NOEXCEPT_TN noexcept
+#endif
+#endif // _MSC_VER
 
 class static_string {
-    const char* const p_;
-    const std::size_t sz_;
+  const char *const p_;
+  const std::size_t sz_;
 
 public:
-    typedef const char* const_iterator;
+  typedef const char *const_iterator;
 
-    template <std::size_t N>
-    CONSTEXPR11_TN static_string(const char(&a)[N]) NOEXCEPT_TN
-        : p_(a)
-        , sz_(N-1)
-        {}
+  template <std::size_t N>
+  CONSTEXPR11_TN static_string(const char (&a)[N]) NOEXCEPT_TN : p_(a),
+                                                                 sz_(N - 1) {}
 
-    CONSTEXPR11_TN static_string(const char* p, std::size_t N) NOEXCEPT_TN
-        : p_(p)
-        , sz_(N)
-        {}
+  CONSTEXPR11_TN static_string(const char *p, std::size_t N) NOEXCEPT_TN
+      : p_(p),
+        sz_(N) {}
 
-    CONSTEXPR11_TN const char* data() const NOEXCEPT_TN {return p_;}
-    CONSTEXPR11_TN std::size_t size() const NOEXCEPT_TN {return sz_;}
+  CONSTEXPR11_TN const char *data() const NOEXCEPT_TN { return p_; }
+  CONSTEXPR11_TN std::size_t size() const NOEXCEPT_TN { return sz_; }
 
-    CONSTEXPR11_TN const_iterator begin() const NOEXCEPT_TN {return p_;}
-    CONSTEXPR11_TN const_iterator end()   const NOEXCEPT_TN {return p_ + sz_;}
+  CONSTEXPR11_TN const_iterator begin() const NOEXCEPT_TN { return p_; }
+  CONSTEXPR11_TN const_iterator end() const NOEXCEPT_TN { return p_ + sz_; }
 
-    CONSTEXPR11_TN char operator[](std::size_t n) const
-    {
-        return n < sz_ ? p_[n] : throw std::out_of_range("static_string");
-    }
+  CONSTEXPR11_TN char operator[](std::size_t n) const {
+    return n < sz_ ? p_[n] : throw std::out_of_range("static_string");
+  }
 };
 
-inline
-std::ostream&
-operator<<(std::ostream& os, static_string const& s)
-{
-    return os.write(s.data(), s.size());
+inline std::ostream &operator<<(std::ostream &os, static_string const &s) {
+  return os.write(s.data(), s.size());
 }
 
-template <class T>
-CONSTEXPR14_TN
-static_string
-type_name()
-{
-  const int k = sizeof("constexpr soi_h::detail:: T =")/sizeof(char);
+template <class T> CONSTEXPR14_TN static_string type_name() {
+  const int k = sizeof("constexpr soi::detail:: T") / sizeof(char);
 #ifdef __clang__
-    static_string p = __PRETTY_FUNCTION__;
-    return static_string(p.data() + 31 + k, p.size() - 31 - k - 1);
+  static_string p = __PRETTY_FUNCTION__;
+  return static_string(p.data() + 31 + k, p.size() - 31 - k - 1);
 #elif defined(__GNUC__)
-    static_string p = __PRETTY_FUNCTION__;
-#  if __cplusplus < 201402
-    return static_string(p.data() + 36 + k, p.size() - 36 - k - 1);
-#  else
-    return static_string(p.data() + 46 + k, p.size() - 46 - k - 1);
-#  endif
+  static_string p = __PRETTY_FUNCTION__;
+#if __cplusplus < 201402
+  return static_string(p.data() + 36 + k, p.size() - 36 - k - 1);
+#else
+  return static_string(p.data() + 46 + k, p.size() - 46 - k - 1);
+#endif
 #elif defined(_MSC_VER)
-    static_string p = __FUNCSIG__;
-    return static_string(p.data() + 38 + k, p.size() - 38 - k - 7);
+  static_string p = __FUNCSIG__;
+  return static_string(p.data() + 38 + k, p.size() - 38 - k - 7);
 #endif
 }
 
 constexpr bool is_prefix_of(char const *suffix, char const *s) {
-  return suffix[0]=='\0' || (suffix[0] == s[0] && is_prefix_of(suffix + 1, s + 1));
+  return suffix[0] == '\0' ||
+         (suffix[0] == s[0] && is_prefix_of(suffix + 1, s + 1));
 }
 
-static char const* const type_string = "string";
+static char const *const type_string = "string";
 
-template <class T>
-CONSTEXPR14_TN
-static_string
-sanitized_type_name() {
+template <class T> CONSTEXPR14_TN static_string sanitized_type_name() {
   CONSTEXPR14_TN static_string t = type_name<T>();
   CONSTEXPR14_TN std::size_t offset =
-    is_prefix_of("std::__debug::", t.data()) ? sizeof("std::__debug::")-1 :
-    is_prefix_of("std::", t.data()) ? sizeof("std::")-1 :
-    0;
-  return
-    is_prefix_of("std::__cxx11::basic_string<char>", t.data()) ?
-    static_string(type_string, sizeof(type_string)-2) :
-    static_string(t.data()+offset, t.size()-offset);
+      is_prefix_of("std::__debug::", t.data())
+          ? sizeof("std::__debug::") - 1
+          : is_prefix_of("std::", t.data()) ? sizeof("std::") - 1 : 0;
+  return is_prefix_of("std::__cxx11::basic_string<char>", t.data())
+             ? static_string(type_string, sizeof(type_string) - 2)
+             : static_string(t.data() + offset, t.size() - offset);
 }
 
 // ----------------------------------------------------------------------------
@@ -152,7 +138,7 @@ bool tty_supports_colors() {
 }
 
 int has_environment_color_overwrite() {
-  if (const char* color_enabled = std::getenv("SOI_COLOR")) {
+  if (const char *color_enabled = std::getenv("SOI_COLOR")) {
     if (!std::strcmp(color_enabled, "1"))
       return 1;
     if (!std::strcmp(color_enabled, "0"))
@@ -172,12 +158,12 @@ bool are_colors_enabled() {
 // init and static variables
 
 static bool colors_enabled = false;
-static const char* ANSI_DEBUG = "";
-static const char* ANSI_EXPRESSION = "";
-static const char* ANSI_VALUE = "";
-static const char* ANSI_TYPE = "";
-static const char* ANSI_MESSAGE = "";
-static const char* ANSI_RESET = "";
+static const char *ANSI_DEBUG = "";
+static const char *ANSI_EXPRESSION = "";
+static const char *ANSI_VALUE = "";
+static const char *ANSI_TYPE = "";
+static const char *ANSI_MESSAGE = "";
+static const char *ANSI_RESET = "";
 
 void dbg_init(bool with_colors) {
   if (with_colors) {
@@ -199,70 +185,51 @@ void dbg_init(bool with_colors) {
   }
 }
 
-void dbg_init() {
-  dbg_init(are_colors_enabled());
-}
+void dbg_init() { dbg_init(are_colors_enabled()); }
 
 // ----------------------------------------------------------------------------
 // printer
 
 template <typename T>
-T&& dbg_print(T&& value,
-              static_string const& type,
-              char const* file,
-              int line,
-              char const* function_name,
-              char const* expression) {
-  const T& ref = value;
-  std::stringstream value_buffer; // avoid nesting of dbg macros within print functinos
-  soi_h::pretty_print(value_buffer, ref);
+T &&dbg_print(T &&value, static_string const &type, char const *file, int line,
+              char const *function_name, char const *expression) {
+  const T &ref = value;
+  std::stringstream
+      value_buffer; // avoid nesting of dbg macros within print functinos
+  soi::print(value_buffer, ref);
 
-  std::cerr << ANSI_DEBUG
-            << "[" << file << ":" << line
-            << " (" << function_name << ")] " << ANSI_RESET
-            << ANSI_EXPRESSION << expression << ANSI_RESET
-            << " = "
-            << ANSI_VALUE << value_buffer.rdbuf() << ANSI_RESET
-            << " (" << ANSI_TYPE << type << ANSI_RESET << ")"
+  std::cerr << ANSI_DEBUG << "[" << file << ":" << line << " (" << function_name
+            << ")] " << ANSI_RESET << ANSI_EXPRESSION << expression
+            << ANSI_RESET << " = " << ANSI_VALUE << value_buffer.rdbuf()
+            << ANSI_RESET << " (" << ANSI_TYPE << type << ANSI_RESET << ")"
             << '\n';
 
   return std::forward<T>(value);
 }
 
-template<unsigned int N>
-auto dbg_print(const char (&msg)[N],
-               static_string const&,
-               char const* file,
-               int line,
-               char const* function_name,
-               char const* expression) -> decltype(msg) {
-  std::cerr << ANSI_DEBUG
-            << "[" << file << ":" << line
-            << " (" << function_name << ")] " << ANSI_RESET
-            << ANSI_MESSAGE << msg << ANSI_RESET
-            << '\n';
+template <unsigned int N>
+auto dbg_print(const char (&msg)[N], static_string const &, char const *file,
+               int line, char const *function_name, char const *expression)
+    -> decltype(msg) {
+  std::cerr << ANSI_DEBUG << "[" << file << ":" << line << " (" << function_name
+            << ")] " << ANSI_RESET << ANSI_MESSAGE << msg << ANSI_RESET << '\n';
   return msg;
 }
 
-template <typename T>
-T&& identity(T&& t) {
-  return std::forward<T>(t);
-}
+template <typename T> T &&identity(T &&t) { return std::forward<T>(t); }
 
 } // end namespace detail
 
-} // end namespace dbg_macro
+} // namespace soi
 
 #ifdef SOI_RELEASE
 #define dbg(...) dbg_macro::identity(__VA_ARGS__)
 #else
-#define dbg(...)                                                        \
-  soi_h::detail::dbg_print((__VA_ARGS__),                               \
-                           soi_h::detail::sanitized_type_name<decltype(__VA_ARGS__)>(), \
-                           __FILE__,                                    \
-                           __LINE__,                                    \
-                           __func__,                                    \
-                           #__VA_ARGS__)
+#define dbg(...)                                                               \
+  soi::detail::dbg_print(                                                      \
+      (__VA_ARGS__),                                                           \
+      soi::detail::sanitized_type_name<decltype(__VA_ARGS__)>(), __FILE__,     \
+      __LINE__, __func__, #__VA_ARGS__)
 #endif
 
-#endif  // SOI_DBG
+#endif // SOI_DBG

include/bits/soi-deprecate.hpp

@@ -1,24 +1,32 @@
 #pragma GCC diagnostic error "-Wdeprecated-declarations"
 
-struct endl_is_evil_t {} endl_is_evil;
-[[deprecated("endl is evil.  Use '\\n' to print a newline.")]] std::ostream & operator<<(std::ostream &os, endl_is_evil_t);
+struct endl_is_evil_t {
+} endl_is_evil;
+[[deprecated("endl is evil.  Use '\\n' to print a newline.")]] std::ostream &
+operator<<(std::ostream &os, endl_is_evil_t);
 #define endl endl_is_evil
 
 #define printf printf_is_evil
 #define fprintf fprintf_is_evil
 #define sprintf sprintf_is_evil
 #define snprintf snprintf_is_evil
-[[deprecated("printf is evil.  Use cout.")]] int printf(const char *format, ...);
-[[deprecated("printf is evil.  Use cout.")]] int fprintf(std::FILE *stream, const char *format, ...);
-[[deprecated("printf is evil.  Use cout.")]] int sprintf(char *buffer, const char *format, ...);
-[[deprecated("printf is evil.  Use cout.")]] int snprintf(char *buffer, std::size_t buf_size, const char *format, ...);
+[[deprecated("printf is evil.  Use cout.")]] int printf(const char *format,
+                                                        ...);
+[[deprecated("printf is evil.  Use cout.")]] int
+fprintf(std::FILE *stream, const char *format, ...);
+[[deprecated("printf is evil.  Use cout.")]] int
+sprintf(char *buffer, const char *format, ...);
+[[deprecated("printf is evil.  Use cout.")]] int
+snprintf(char *buffer, std::size_t buf_size, const char *format, ...);
 
 #define scanf scanf_is_evil
 #define fscanf fscanf_is_evil
 #define sscanf sscanf_is_evil
 [[deprecated("scanf is evil.  Use cin.")]] int scanf(const char *format, ...);
-[[deprecated("scanf is evil.  Use cin.")]] int fscanf(std::FILE *stream, const char *format, ...);
-[[deprecated("scanf is evil.  Use cin.")]] int sscanf(const char *buffer, const char *format, ...);
+[[deprecated("scanf is evil.  Use cin.")]] int fscanf(std::FILE *stream,
+                                                      const char *format, ...);
+[[deprecated("scanf is evil.  Use cin.")]] int sscanf(const char *buffer,
+                                                      const char *format, ...);
 
 #define puts puts_is_evil
 #define fputs fputs_is_evil
@@ -35,28 +43,45 @@ struct endl_is_evil_t {} endl_is_evil;
 #define fread fread_is_evil
 #define fwrite fwrite_is_evil
 [[deprecated("<cstdio> is evil.  Use cin/cout.")]] int puts(const char *str);
-[[deprecated("<cstdio> is evil.  Use cin/cout.")]] int fputs(const char *str, FILE *stream);
-[[deprecated("<cstdio> is evil.  Use cin/cout.")]] char *fgets(char *str, int count, FILE *stream);
-[[deprecated("<cstdio> is evil.  Use cin/cout.")]] std::FILE *freopen(const char *filename, const char *mode, std::FILE *stream);
-[[deprecated("<cstdio> is evil.  Use cin/cout.")]] std::FILE *fopen(const char *filename, const char *mode);
-[[deprecated("<cstdio> is evil.  Use cin/cout.")]] int fclose(std::FILE *stream);
-[[deprecated("<cstdio> is evil.  Use cin/cout.")]] int fflush(std::FILE *stream);
+[[deprecated("<cstdio> is evil.  Use cin/cout.")]] int fputs(const char *str,
+                                                             FILE *stream);
+[[deprecated("<cstdio> is evil.  Use cin/cout.")]] char *
+fgets(char *str, int count, FILE *stream);
+[[deprecated("<cstdio> is evil.  Use cin/cout.")]] std::FILE *
+freopen(const char *filename, const char *mode, std::FILE *stream);
+[[deprecated("<cstdio> is evil.  Use cin/cout.")]] std::FILE *
+fopen(const char *filename, const char *mode);
+[[deprecated("<cstdio> is evil.  Use cin/cout.")]] int
+fclose(std::FILE *stream);
+[[deprecated("<cstdio> is evil.  Use cin/cout.")]] int
+fflush(std::FILE *stream);
 [[deprecated("<cstdio> is evil.  Use cin/cout.")]] int getchar();
 [[deprecated("<cstdio> is evil.  Use cin/cout.")]] int fgetc(std::FILE *stream);
 [[deprecated("<cstdio> is evil.  Use cin/cout.")]] int getc(std::FILE *stream);
-[[deprecated("<cstdio> is evil.  Use cin/cout.")]] void setbuf(std::FILE *stream, char *buffer);
-[[deprecated("<cstdio> is evil.  Use cin/cout.")]] int setvbuf(std::FILE *stream, char *buffer, int mode, std::size_t size);
-[[deprecated("<cstdio> is evil.  Use cin/cout.")]] std::size_t fread(void *buffer, std::size_t size, std::size_t count, std::FILE *stream);
-[[deprecated("<cstdio> is evil.  Use cin/cout.")]] std::size_t fwrite(const void *buffer, std::size_t size, std::size_t count, std::FILE *stream);
+[[deprecated("<cstdio> is evil.  Use cin/cout.")]] void
+setbuf(std::FILE *stream, char *buffer);
+[[deprecated("<cstdio> is evil.  Use cin/cout.")]] int
+setvbuf(std::FILE *stream, char *buffer, int mode, std::size_t size);
+[[deprecated("<cstdio> is evil.  Use cin/cout.")]] std::size_t
+fread(void *buffer, std::size_t size, std::size_t count, std::FILE *stream);
+[[deprecated("<cstdio> is evil.  Use cin/cout.")]] std::size_t
+fwrite(const void *buffer, std::size_t size, std::size_t count,
+       std::FILE *stream);
 
 #define malloc malloc_is_evil
 #define calloc calloc_is_evil
 #define realloc realloc_is_evil
 #define free free_is_evil
-[[deprecated("malloc/free is evil.  Use a vector.")]] void *malloc(std::size_t size);
-[[deprecated("malloc/free is evil.  Use a vector.")]] void *calloc(std::size_t num, std::size_t size);
-[[deprecated("malloc/free is evil.  Use a vector.")]] void *realloc(void *ptr, std::size_t new_size);
-[[deprecated("malloc/free is evil.  Use a vector.")]] void *free(void *ptr, std::size_t new_size);
+[[deprecated("malloc/free is evil.  Use a vector.")]] void *
+malloc(std::size_t size);
+[[deprecated("malloc/free is evil.  Use a vector.")]] void *
+calloc(std::size_t num, std::size_t size);
+[[deprecated("malloc/free is evil.  Use a vector.")]] void *
+realloc(void *ptr, std::size_t new_size);
+[[deprecated("malloc/free is evil.  Use a vector.")]] void *
+free(void *ptr, std::size_t new_size);
 
-[[deprecated("new is evil.  Use a vector.")]] void *operator new(std::size_t sz);
-[[deprecated("delete is evil.  Use a vector.")]] void operator delete(void *ptr) noexcept;
+[[deprecated("new is evil.  Use a vector.")]] void *
+operator new(std::size_t sz);
+[[deprecated("delete is evil.  Use a vector.")]] void
+operator delete(void *ptr) noexcept;

include/bits/soi-pretty.hpp

@@ -3,7 +3,7 @@
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 //
-// pretty printing with c++
+// pretty pretty_printing with c++
 //
 
 #ifndef SOI_PRETTY
@@ -11,66 +11,90 @@
 
 #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> &
-pretty_print(std::basic_ostream<TChar, TCharTraits> & stream, const bool& x) {
+pretty_print(std::basic_ostream<TChar, TCharTraits> &stream, const bool &x) {
   return stream << (x ? "true" : "false");
 }
 
 namespace detail {
-template<typename TChar, typename TCharTraits>
-void escape_char(std::basic_ostream<TChar, TCharTraits> & stream, char c) {
+template <typename TChar, typename TCharTraits>
+void escape_char(std::basic_ostream<TChar, TCharTraits> &stream, char c) {
   switch (c) {
-  case '\a': stream << "\\a"; break;
-  case '\b': stream << "\\b"; break;
-  case '\t': stream << "\\t"; break;
-  case '\n': stream << "\\n"; break;
-  case '\v': stream << "\\v"; break;
-  case '\f': stream << "\\f"; break;
-  case '\r': stream << "\\r"; break;
-  case '\e': stream << "\\e"; break;
-  case '\"': stream << "\\\""; break;
-  case '\'': stream << "\\'"; break;
-  case '\?': stream << "\\?"; break;
-  case '\\': stream << "\\\\"; break;
-  default: stream << c;
+  case '\a':
+    stream << "\\a";
+    break;
+  case '\b':
+    stream << "\\b";
+    break;
+  case '\t':
+    stream << "\\t";
+    break;
+  case '\n':
+    stream << "\\n";
+    break;
+  case '\v':
+    stream << "\\v";
+    break;
+  case '\f':
+    stream << "\\f";
+    break;
+  case '\r':
+    stream << "\\r";
+    break;
+  case '\e':
+    stream << "\\e";
+    break;
+  case '\"':
+    stream << "\\\"";
+    break;
+  case '\'':
+    stream << "\\'";
+    break;
+  case '\?':
+    stream << "\\?";
+    break;
+  case '\\':
+    stream << "\\\\";
+    break;
+  default:
+    stream << c;
   }
 }
-}
+} // namespace detail
 
-template<typename TChar, typename TCharTraits>
+template <typename TChar, typename TCharTraits>
 std::basic_ostream<TChar, TCharTraits> &
-pretty_print(std::basic_ostream<TChar, TCharTraits> & stream, const std::string& x) {
+pretty_print(std::basic_ostream<TChar, TCharTraits> &stream,
+             const std::string &x) {
   stream << "\"";
   for (char c : x)
     detail::escape_char(stream, c);
   return stream << "\"";
 }
 
-template<typename TChar, typename TCharTraits>
+template <typename TChar, typename TCharTraits>
 std::basic_ostream<TChar, TCharTraits> &
-pretty_print(std::basic_ostream<TChar, TCharTraits> & stream, char c) {
+pretty_print(std::basic_ostream<TChar, TCharTraits> &stream, char c) {
   stream << "'";
   detail::escape_char(stream, c);
   return stream << "'";
 }
 
-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& x) {
+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 &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);
 }
+} // namespace soi
 
 #endif // SOI_PRETTY

include/soi

@@ -5,20 +5,20 @@
    have to understand every concept all at once.
 */
 
-#include <fstream>
 #include "bits/soi-dbg.hpp"
+#include <fstream>
 
-namespace soi_h {
+namespace soi {
 
 void check_for_eof() {
-    if (!(std::cin >> std::ws).eof())
-        std::cerr << "WARNING: didn't read the whole input\n";
+  if (!(std::cin >> std::ws).eof())
+    std::cerr << "WARNING: didn't read the whole input\n";
 }
 
 void noninteractive_check_eof() {
   // make symbol 0x1A (Ctrl+Z) a whitespace
   struct console_ctype : std::ctype<char> {
-    static const mask* get_table() {
+    static const mask *get_table() {
       static const std::array<mask, table_size> table = []() {
         std::array<mask, table_size> table;
         std::copy(classic_table(), classic_table() + table_size, table.begin());
@@ -27,14 +27,14 @@ void noninteractive_check_eof() {
       }();
       return table.data();
     }
-  console_ctype(std::size_t refs = 0) : ctype(get_table(), false, refs) {}
+    console_ctype(std::size_t refs = 0) : ctype(get_table(), false, refs) {}
   };
   std::cin.imbue(std::locale(std::cin.getloc(), new console_ctype));
   check_for_eof();
 }
 
 bool should_check_for_eof() {
-  if (const char* eofcheck_enabled = std::getenv("SOI_EOFCHECK")) {
+  if (const char *eofcheck_enabled = std::getenv("SOI_EOFCHECK")) {
     if (!std::strcmp(eofcheck_enabled, "1"))
       return true;
     if (!std::strcmp(eofcheck_enabled, "0"))
@@ -48,15 +48,15 @@ void initialize_debug() {
   std::cin.exceptions(std::ifstream::failbit | std::ifstream::badbit);
   std::ios::sync_with_stdio(false);
 
-  if (should_check_for_eof() &&
-      std::atexit(noninteractive_check_eof) != 0) {
-    std::cerr << "WARNING: soi.h -- registration of sanity check at exit failed\n";
+  if (should_check_for_eof() && std::atexit(noninteractive_check_eof) != 0) {
+    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 {
-  soi_h_initializer(bool release) {
+struct soi_initializer {
+  soi_initializer(bool release) {
     if (release) {
       std::ios::sync_with_stdio(false);
       std::cin.tie(0);
@@ -67,12 +67,12 @@ struct soi_h_initializer {
 };
 
 #ifdef SOI_RELEASE
-soi_h_initializer soi_h_initializer_{true};
+soi_initializer soi_initializer_{true};
 #else
-soi_h_initializer soi_h_initializer_{false};
+soi_initializer soi_initializer_{false};
 #endif
 
-} // end namespace soi_h
+} // end namespace soi
 
 #include "bits/soi-deprecate.hpp"