print.hpp

Go to the documentation of this file.

//====================================================
//     File data
//====================================================
//====================================================
//     Preprocessor directives
//====================================================
#pragma once
#ifndef PYTHON_TO_CPP_PRINT_HPP
#define PYTHON_TO_CPP_PRINT_HPP
 
//====================================================
//     Headers
//====================================================
 
// Standard headers
#include <iostream>
#include <sstream>
#include <string>
#include <string_view>
#include <type_traits>
#include <mutex>
#include <utility>
#include <locale>
#include <codecvt>
 
// Extra types headers
#ifndef PTC_DISABLE_STD_TYPES_PRINTING
#include <stddef.h>
#include <complex>
#include <array>
#include <stack>
#include <queue>
#include <chrono>
#include <unordered_map>
#include <typeindex>
#include <iterator>
#include <optional>
#include <ratio>
#include <algorithm>
#endif
 
//====================================================
//     Namespaces
//====================================================
using namespace std::literals::string_literals;
 
namespace ptc
 {
  //====================================================
  //     Enum classes
  //====================================================
 
  // mode
   enum class mode { str };
 
  // ANSI_pos
   enum class ANSI { first, generic };
 
  //====================================================
  //     Helper tools
  //====================================================
 
  namespace
   {
    // StringConverter
    template <class CharT>
    std::conditional_t<std::is_same_v<CharT, char>, const std::basic_string<CharT>&, std::basic_string<CharT>>
    StringConverter( const std::string& input_str )
     {
      if constexpr( std::is_same_v <CharT, char> ) 
       {
        return input_str;
       }
      else if constexpr( std::is_same_v <CharT, wchar_t> )
       {
        static std::wstring_convert <std::codecvt_utf8_utf16 <wchar_t>> converter_wchar_t;
        return converter_wchar_t.from_bytes( input_str );
       }
      #ifndef __APPLE__
      #if ( __cplusplus >= 202002L )
      else if constexpr( std::is_same_v <CharT, char8_t> )
       {
        return reinterpret_cast <const char8_t*>( input_str.c_str() );
       }
      #endif
      else if constexpr( std::is_same_v <CharT, char16_t> )
       {
        static std::wstring_convert <std::codecvt_utf8_utf16 <char16_t>, char16_t> converter_16_t;
        return converter_16_t.from_bytes( input_str );
       } 
      else if constexpr( std::is_same_v <CharT, char32_t> )
       {
        static std::wstring_convert <std::codecvt_utf8_utf16 <char32_t>, char32_t> converter_32_t;
        return converter_32_t.from_bytes( input_str );
       }
      #endif
      else 
       {
        return StringConverter<CharT>( "" );
       }
     }
  
    #ifndef PTC_DISABLE_STD_TYPES_PRINTING
  
    // is_streamable
    template <class T, class T_str>
    struct is_streamable 
     {
      static std::false_type test( ... );
        
      template<class U>
      static auto test( const U& u ) -> decltype( std::declval <std::basic_ostream<T_str>&>() << u, std::true_type{} );
    
      static constexpr bool value = decltype( test( std::declval <T>() ) )::value;
     };
    
    template<class T, class T_str>
    inline constexpr bool is_streamable_v = is_streamable<T, T_str>::value;
  
    // Helper function for container adaptors printing
    template <class Container, class T_str>
    inline void print_adaptor( std::basic_ostream<T_str>& os, const Container& container )
     {
      typename Container::const_iterator beg = container.begin();
      std::basic_string<T_str> separator = StringConverter<T_str>( ""s );
      
      while( beg != container.end() )
       {
        os << separator << *beg++;
        separator = StringConverter<T_str>( ", "s );
       }
     }
    
    // container_mod overload for std::stack hacked printing
    template <class Type, class Container>
    const Container& container_mod( const std::stack<Type, Container>& stack )
     {
      struct HackedStack : private std::stack<Type, Container>
       {
        static const Container& container( const std::stack<Type, Container>& stack )
         {
          return stack.*&HackedStack::c;
         }
       };
    
      return HackedStack::container( stack );
     }
  
    // container_mod overload for std::priority_queue hacked printing
    template < class Type, class Container >
    const Container& container_mod( const std::priority_queue<Type, Container>& priority_queue )
     {
      struct HackedQueue : private std::priority_queue<Type, Container>
       {
        static const Container& container( const std::priority_queue<Type, Container>& priority_queue )
         {
          return priority_queue.*&HackedQueue::c;
         }
       };
  
      return HackedQueue::container( priority_queue );
     }
  
    //====================================================
    //     Operator << overloads for stdlib types
    //====================================================
  
    #if defined( __GNUC__ ) && ( __GNUC___ <= 9 )
  
    // Overload for std::nullptr_t
    template <class T_str>
    inline std::basic_ostream<T_str>& operator << ( std::basic_ostream<T_str>& os, std::nullptr_t )
     {
      os << "nullptr";
      return os; 
     }
  
    #endif
  
    // Overload for std::complex
    template <class T_str, class T_cmplx>
    inline std::basic_ostream<T_str>& operator << ( std::basic_ostream<T_str>& os, const std::complex<T_cmplx>& number )
     {
      os << number.real() << '+' << number.imag() << 'j';
  
      return os; 
     }
  
    // Helper overload for std::vector and std::map
    template <class T_str, class T, class U>
    inline std::basic_ostream<T_str>& operator <<( std::basic_ostream<T_str>& os, const std::pair <T, U>& p ) 
     {
      os << '[' << p.first << ", " << p.second << ']';
  
      return os;
     } 
  
    // Overload for all containers printing
    template <template <typename, typename...> class ContainerType, typename ValueType, typename... Args, class T_str>
    std::enable_if_t< ! is_streamable_v <ContainerType <ValueType, Args...>, T_str>, std::basic_ostream<T_str>&>
    operator <<( std::basic_ostream<T_str>& os, const ContainerType<ValueType, Args...>& container ) 
     {
      static bool constexpr is_stack = std::is_same_v <ContainerType<ValueType, Args...>, std::stack<ValueType>>;
      static bool constexpr is_pqueue = std::is_same_v <ContainerType<ValueType, Args...>, std::priority_queue<ValueType>>;
      
      os << '[';
      if constexpr ( ! is_stack && ! is_pqueue )
       {
        std::basic_string<T_str> separator = StringConverter<T_str>( ""s );
        for ( const auto& elem: container )
         {
          os << separator;
          os << elem;
          separator = StringConverter<T_str>( ", "s );
         }
       }
      else
       {
        print_adaptor( os, container_mod( container ) );
       }
      os << ']';
  
      return os;
     }
  
    // Overload for std::array printing
    template <class T_str, class T, size_t T_no>
    std::basic_ostream<T_str>& operator <<( std::basic_ostream<T_str>& os, const std::array<T, T_no>& container ) 
     {
      std::basic_string<T_str> separator = StringConverter<T_str>( ""s );
  
      os << '[';
      std::copy
       (
        std::begin( container ),
        std::prev( container.end() ),
        std::ostream_iterator <T> { os, ", " }
       );
      os << container.back();
      os << ']';
  
      return os;
     }
  
    // Overload for C arrays
    template <class T_str, class T1, size_t arrSize, 
    typename = std::enable_if_t< ! std::is_same <T1,char>::value>>
    std::basic_ostream<T_str>& operator <<( std::basic_ostream<T_str>& os, const T1( & arr )[ arrSize ] )
     {
      os << '[';
      if ( arrSize )
       {
        std::basic_string<T_str> separator = StringConverter<T_str>( ""s );
        for ( const auto& elem: arr )
         {
          os << separator;
          os << elem;
          separator = StringConverter<T_str>( ", "s );
         }
       }
      os << ']';
  
      return os;
     }
  
    // Overload for std::chrono::duration objects
    template <class T_str, class T_time, class int_type>
    std::basic_ostream<T_str>& operator <<( std::basic_ostream<T_str>& os, const std::chrono::duration<int_type, T_time>& val )
     {
      if constexpr( ! std::is_same_v<std::chrono::duration<int_type, T_time>, std::chrono::duration<int_type>> )
       {
        static std::unordered_map<std::type_index, std::basic_string_view<T_str>> time_map
         {
          { typeid( std::nano ), StringConverter<T_str>( "ns" ) },
          { typeid( std::micro ), StringConverter<T_str>( "us" ) },
          { typeid( std::milli ), StringConverter<T_str>( "ms" ) },
          { typeid( std::ratio<60> ), StringConverter<T_str>( "min" ) },
          { typeid( std::ratio<3600> ), StringConverter<T_str>( "h" ) }
         };
  
        #if ( __cplusplus >= 202002L )
        time_map.insert( { typeid( std::ratio<86400> ), StringConverter<T_str>( "d" ) } );
        time_map.insert( { typeid( std::ratio<604800> ), StringConverter<T_str>( "w" ) } );
        time_map.insert( { typeid( std::ratio<2629746> ), StringConverter<T_str>( "mos" ) } );
        time_map.insert( { typeid( std::ratio<31556952> ), StringConverter<T_str>( "y" ) } );
        #endif
         
        os << val.count() << time_map[ typeid( T_time ) ];
       }
      else if constexpr( std::is_same_v<std::chrono::duration<int_type, T_time>, std::chrono::duration<int_type>> )
       {
        os << val.count() << 's';
       }
  
      return os;
     }
  
    // Overload for std::optional
    template <class T_str, class T>
    std::basic_ostream<T_str>& operator <<( std::basic_ostream<T_str>& os, std::optional<T> const& opt )
     {
      if ( opt ) os << opt.value();
      else os << "nullopt"; 
      
      return os;
     }
 
    // Overload for std::tuple
    template<std::size_t...> 
    struct seq{};
 
    template<std::size_t N, std::size_t... Is>
    struct gen_seq: gen_seq<N-1, N-1, Is...>{};
 
    template<std::size_t... Is>
    struct gen_seq<0, Is...> : seq<Is...>{};
 
    template<class T_str, class Tuple, std::size_t... Is>
    void print_tuple( std::basic_ostream<T_str>& os, const Tuple& tup, seq<Is...> )
     {
      using swallow = int[];
      ( void )swallow{ 0, ( void( os << ( Is == 0 ? "" : ", " ) << std::get<Is>( tup ) ), 0 )... };
     }
    
    template<class T_str, class... Args>
    std::basic_ostream<T_str>& operator<<( std::basic_ostream<T_str>& os, const std::tuple<Args...>& tup )
     {
      os << "(";
      print_tuple( os, tup, gen_seq<sizeof...( Args )>() );
      os << ")";
 
      return os;
     }
  
    #endif
  
    //====================================================
    //     Functions used to select printing format
    //====================================================
  
    // ptr
    template <class T_str = char, class T>
    std::basic_string<T_str> ptr( T* ptr )
     {
      static std::basic_ostringstream<T_str> oss;
      oss.str( StringConverter<T_str>( ""s ) );
      oss.clear();
  
      oss << "Value: " << ptr << "\n";
      oss << "Address: " << &ptr;
  
      return oss.str();
     }
   }
 
  //====================================================
  //     ptc_print class
  //====================================================
  template <class T_str>
  struct Print
   {
    //====================================================
    //     Public constructors and destructor
    //====================================================
 
    // Default constructor
    explicit Print(): 
     end( StringConverter<T_str>( "\n"s ) ),
     sep( StringConverter<T_str>( " "s ) ),
     flush( false )
     {       
      #ifdef PTC_ENABLE_PERFORMANCE_IMPROVEMENTS
      performance_options();
      #endif
     }
 
    //====================================================
    //     Public structs
    //====================================================
 
    // select_cout
    template <class T> 
    struct select_cout
     {
      static std::basic_ostream<T> &cout;
     };
 
    #ifdef PTC_ENABLE_PERFORMANCE_IMPROVEMENTS
   
    // select_cin
    template <class T> 
    struct select_cin
     {
      static std::basic_istream<T> &cin;
     };
  
    #endif
 
    //====================================================
    //     Public setters
    //====================================================
 
    // setEnd
    template <class T> 
    inline void setEnd( const T& end_val )
     {
      end = end_val;
     }
 
    // setSep
    template <class T>
    inline void setSep( const T& sep_val )
     {
      sep = sep_val;
     }
 
    // setFlush
    inline void setFlush( const bool& flush_val )
     {
      flush = flush_val;
     }
    
    // setPattern
    template <class T>
    inline void setPattern( const T& pattern_val )
     {
      pattern = pattern_val;
     }
 
    //====================================================
    //     Public getters
    //====================================================
 
    #ifdef PTC_ENABLE_GETTERS_FOR_UNIT_TESTS
 
    // getEnd
    inline const auto& getEnd() const 
     {
      return end;
     }
 
    // getSep
    inline const auto& getSep() const
     {
      return sep;
     }
 
    // getFlush
    inline const bool& getFlush() const
     {
      return flush;
     }
 
    // getPattern
    inline const auto& getPattern() const
     {
      return pattern;
     }
 
    #endif
 
    //====================================================
    //     Public operator () overloads
    //====================================================
 
    // General case
    template <class T, class... Args>
    void operator()( T&& first, Args&&... args ) const
     {
      if constexpr ( std::is_base_of_v <std::basic_ostream<T_str>, std::remove_reference_t<T>> )
       {
        print_backend( std::forward<T>( first ), std::forward<Args>( args )... );
       }
      else
       {
        print_backend( select_cout<T_str>::cout, std::forward<T>( first ), std::forward<Args>( args )... );
       }
     }
 
    // String initialization case
    template <class... Args>
    const std::basic_string<T_str> operator()( mode&& first, Args&&... args ) const
     { 
      if constexpr( sizeof...( args ) > 0 )
       {
        switch( first )
         {
          case mode::str:
           {
            static std::basic_ostringstream<T_str> oss;
            oss.str( StringConverter<T_str>( ""s ) );
            oss.clear();
            print_backend( oss, std::forward<Args>( args )... );
 
            return oss.str();
           }
         }
       }
       
      return StringConverter<T_str>( "" );
     }
 
    // No arguments case
    inline void operator () ( std::basic_ostream<T_str>& os = select_cout<T_str>::cout ) const
     {
      os << end;
      if ( flush ) os << std::flush;
     }
     
   private:
 
    //====================================================
    //     Private methods
    //====================================================
 
    // is_escape
    template <typename T>
    static constexpr bool is_escape( const T& str, const ANSI& flag )
     {
      if constexpr( std::is_convertible_v <T, std::basic_string_view<T_str>> && ! std::is_same_v<T, std::nullptr_t> )
       {
        switch( flag )
         {
          case( ANSI::first ): 
           {
            return ( std::basic_string_view<T_str>( str ).length() < 7 ) && ( str[0] == '\033' );
           }
          case( ANSI::generic ):
           {
            return ( std::basic_string_view<T_str>( str ).find( '\033' ) != std::basic_string_view<T_str>::npos );
           }
         }
       }
      return false;
     }
      
    // print_backend
    template <class T_os, class T, class... Args>
    void print_backend( T_os&& os, T&& first, Args&&... args ) const
     {
      std::lock_guard <std::mutex> lock{ mutex_ };
 
      // Printing the first argument
      if( is_escape( first, ANSI::first ) || pattern.empty() ) os << first;
      else os << pattern << first << pattern;
      
      // Printing all the other arguments
      if constexpr( sizeof...( args ) > 0 ) 
       {
        if ( is_escape( first, ANSI::first ) ) 
         {
          if( pattern.empty() ) ( ( os << args << sep ), ...);
          else ( ( os << pattern << args << pattern << sep ), ...);
         }
        else 
         {
          if( pattern.empty() ) ( ( os << sep << args ), ...);
          else ( ( os << sep << pattern << args << pattern ), ...);
         }
       }
      os << end;
      
      // Resetting the stream from ANSI escape sequences
      if constexpr( sizeof...( args ) > 0 )
       {
        if ( is_escape( first, ANSI::generic ) || ( ( is_escape( args, ANSI::generic ) ) || ...) )
         {
          os << "\033[0m";
         }
       }
      else 
       {
       if ( is_escape( first, ANSI::generic ) ) 
        {
         os << "\033[0m";
        }
       }
 
      // Other operations
      if ( flush ) os << std::flush;
     }
 
    // performance_options
    inline void performance_options() const
     {
      std::lock_guard <std::mutex> lock{ mutex_ };
      
      std::ios_base::sync_with_stdio( false );
      select_cout<T_str>::cout.tie( nullptr );
 
      #ifdef PTC_ENABLE_PERFORMANCE_IMPROVEMENTS
      select_cin<T_str>::cin.tie( nullptr );
      #endif
     }
     
    //====================================================
    //     Private attributes
    //====================================================
    std::basic_string<T_str> end, sep, pattern;
    static std::mutex mutex_;
    bool flush;
   };
   
  //====================================================
  //     Other steps
  //====================================================
 
  // Print structs specializations
  template <> template <> inline std::ostream &Print<char>::select_cout <char>::cout = std::cout;
  template <> template <> inline std::wostream &Print<wchar_t>::select_cout <wchar_t>::cout = std::wcout;
 
  #ifdef PTC_ENABLE_PERFORMANCE_IMPROVEMENTS
  template <> template <> inline std::istream &Print<char>::select_cin <char>::cin = std::cin;
  template <> template <> inline std::wistream &Print<wchar_t>::select_cin <wchar_t>::cin = std::wcin;
  #endif
 
  // Print::mutex_ definiton
  template <class T_str> inline std::mutex Print <T_str>::mutex_;
 
  // Print objects initialization
  inline Print <char> print;        // char
  inline Print <wchar_t> wprint;    // wchar_t
 
  #if ! defined( PTC_ENABLE_PERFORMANCE_IMPROVEMENTS ) && ! defined( __APPLE__ )
  #if ( __cplusplus >= 202002L )
  inline Print <char8_t> print8;  // char8_t
  #endif
  inline Print <char16_t> print16;  // char16_t
  inline Print <char32_t> print32;  // char32_t
  #endif
 }
 
#endif