Merge pull request #60 from data-man/termcolor_latest

Update termcolor to latest

include/indicators/termcolor.hpp

@@ -17,360 +17,539 @@
 // defines the appropriate macro that is used to wrap some
 // platform specific things
 #if defined(_WIN32) || defined(_WIN64)
-#define TERMCOLOR_OS_WINDOWS
+#   define TERMCOLOR_OS_WINDOWS
 #elif defined(__APPLE__)
-#define TERMCOLOR_OS_MACOS
+#   define TERMCOLOR_OS_MACOS
 #elif defined(__unix__) || defined(__unix)
-#define TERMCOLOR_OS_LINUX
+#   define TERMCOLOR_OS_LINUX
 #else
-#error unsupported platform
+#   error unsupported platform
 #endif
 
+
 // This headers provides the `isatty()`/`fileno()` functions,
 // which are used for testing whether a standart stream refers
 // to the terminal. As for Windows, we also need WinApi funcs
 // for changing colors attributes of the terminal.
 #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
-#include <unistd.h>
+#   include <unistd.h>
 #elif defined(TERMCOLOR_OS_WINDOWS)
-#if !defined(NOMINMAX)
+#   include <io.h>
-#define NOMINMAX
+#   include <windows.h>
-#endif
-#include <io.h>
-#include <windows.h>
 #endif
 
-#include <cstdio>
+
 #include <iostream>
+#include <cstdio>
 
-namespace termcolor {
-// Forward declaration of the `_internal` namespace.
-// All comments are below.
-namespace _internal {
-// An index to be used to access a private storage of I/O streams. See
-// colorize / nocolorize I/O manipulators for details.
-static int colorize_index = std::ios_base::xalloc();
 
-inline FILE *get_standard_stream(const std::ostream &stream);
+namespace termcolor
-inline bool is_colorized(std::ostream &stream);
+{
-inline bool is_atty(const std::ostream &stream);
+    // Forward declaration of the `_internal` namespace.
+    // All comments are below.
+    namespace _internal
+    {
+        // An index to be used to access a private storage of I/O streams. See
+        // colorize / nocolorize I/O manipulators for details.
+        static int colorize_index = std::ios_base::xalloc();
 
-#if defined(TERMCOLOR_OS_WINDOWS)
+        inline FILE* get_standard_stream(const std::ostream& stream);
-inline void win_change_attributes(std::ostream &stream, int foreground, int background = -1);
+        inline bool is_colorized(std::ostream& stream);
-#endif
+        inline bool is_atty(const std::ostream& stream);
-} // namespace _internal
 
-inline std::ostream &colorize(std::ostream &stream) {
+    #if defined(TERMCOLOR_OS_WINDOWS)
+        inline void win_change_attributes(std::ostream& stream, int foreground, int background=-1);
+    #endif
+    }
+
+    inline
+    std::ostream& colorize(std::ostream& stream)
+    {
         stream.iword(_internal::colorize_index) = 1L;
         return stream;
-}
+    }
 
-inline std::ostream &nocolorize(std::ostream &stream) {
+    inline
+    std::ostream& nocolorize(std::ostream& stream)
+    {
         stream.iword(_internal::colorize_index) = 0L;
         return stream;
-}
+    }
 
-inline std::ostream &reset(std::ostream &stream) {
+    inline
-  if (_internal::is_colorized(stream)) {
+    std::ostream& reset(std::ostream& stream)
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+    {
+        if (_internal::is_colorized(stream))
+        {
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
             stream << "\033[00m";
-#elif defined(TERMCOLOR_OS_WINDOWS)
+        #elif defined(TERMCOLOR_OS_WINDOWS)
             _internal::win_change_attributes(stream, -1, -1);
-#endif
+        #endif
         }
         return stream;
-}
+    }
 
-inline std::ostream &bold(std::ostream &stream) {
+    inline
-  if (_internal::is_colorized(stream)) {
+    std::ostream& bold(std::ostream& stream)
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+    {
+        if (_internal::is_colorized(stream))
+        {
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
             stream << "\033[1m";
-#elif defined(TERMCOLOR_OS_WINDOWS)
+        #elif defined(TERMCOLOR_OS_WINDOWS)
-#endif
+        #endif
         }
         return stream;
-}
+    }
 
-inline std::ostream &dark(std::ostream &stream) {
+    inline
-  if (_internal::is_colorized(stream)) {
+    std::ostream& dark(std::ostream& stream)
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+    {
+        if (_internal::is_colorized(stream))
+        {
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
             stream << "\033[2m";
-#elif defined(TERMCOLOR_OS_WINDOWS)
+        #elif defined(TERMCOLOR_OS_WINDOWS)
-#endif
+        #endif
         }
         return stream;
-}
+    }
 
-inline std::ostream &italic(std::ostream &stream) {
+    inline
-  if (_internal::is_colorized(stream)) {
+    std::ostream& italic(std::ostream& stream)
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+    {
+        if (_internal::is_colorized(stream))
+        {
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
             stream << "\033[3m";
-#elif defined(TERMCOLOR_OS_WINDOWS)
+        #elif defined(TERMCOLOR_OS_WINDOWS)
-#endif
+        #endif
         }
         return stream;
-}
+    }
 
-inline std::ostream &underline(std::ostream &stream) {
+    inline
-  if (_internal::is_colorized(stream)) {
+    std::ostream& underline(std::ostream& stream)
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+    {
+        if (_internal::is_colorized(stream))
+        {
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
             stream << "\033[4m";
-#elif defined(TERMCOLOR_OS_WINDOWS)
+        #elif defined(TERMCOLOR_OS_WINDOWS)
-#endif
+        #endif
         }
         return stream;
-}
+    }
 
-inline std::ostream &blink(std::ostream &stream) {
+    inline
-  if (_internal::is_colorized(stream)) {
+    std::ostream& blink(std::ostream& stream)
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+    {
+        if (_internal::is_colorized(stream))
+        {
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
             stream << "\033[5m";
-#elif defined(TERMCOLOR_OS_WINDOWS)
+        #elif defined(TERMCOLOR_OS_WINDOWS)
-#endif
+        #endif
         }
         return stream;
-}
+    }
 
-inline std::ostream &reverse(std::ostream &stream) {
+    inline
-  if (_internal::is_colorized(stream)) {
+    std::ostream& reverse(std::ostream& stream)
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+    {
+        if (_internal::is_colorized(stream))
+        {
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
             stream << "\033[7m";
-#elif defined(TERMCOLOR_OS_WINDOWS)
+        #elif defined(TERMCOLOR_OS_WINDOWS)
-#endif
+        #endif
         }
         return stream;
-}
+    }
 
-inline std::ostream &concealed(std::ostream &stream) {
+    inline
-  if (_internal::is_colorized(stream)) {
+    std::ostream& concealed(std::ostream& stream)
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+    {
+        if (_internal::is_colorized(stream))
+        {
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
             stream << "\033[8m";
-#elif defined(TERMCOLOR_OS_WINDOWS)
+        #elif defined(TERMCOLOR_OS_WINDOWS)
-#endif
+        #endif
         }
         return stream;
-}
+    }
 
-inline std::ostream &crossed(std::ostream &stream) {
+    inline
-  if (_internal::is_colorized(stream)) {
+    std::ostream& crossed(std::ostream& stream)
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+    {
+        if (_internal::is_colorized(stream))
+        {
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
             stream << "\033[9m";
-#elif defined(TERMCOLOR_OS_WINDOWS)
+        #elif defined(TERMCOLOR_OS_WINDOWS)
-#endif
+        #endif
         }
         return stream;
-}
+    }
 
-inline std::ostream &grey(std::ostream &stream) {
+    template <uint8_t code> inline
-  if (_internal::is_colorized(stream)) {
+    std::ostream& color(std::ostream& stream)
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+    {
+        if (_internal::is_colorized(stream))
+        {
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+            char command[12];
+            std::snprintf(command, sizeof(command), "\033[38;5;%dm", code);
+            stream << command;
+        #elif defined(TERMCOLOR_OS_WINDOWS)
+        #endif
+        }
+        return stream;
+    }
+
+    template <uint8_t code> inline
+    std::ostream& on_color(std::ostream& stream)
+    {
+        if (_internal::is_colorized(stream))
+        {
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+            char command[12];
+            std::snprintf(command, sizeof(command), "\033[48;5;%dm", code);
+            stream << command;
+        #elif defined(TERMCOLOR_OS_WINDOWS)
+        #endif
+        }
+        return stream;
+    }
+
+    template <uint8_t r, uint8_t g, uint8_t b> inline
+    std::ostream& color(std::ostream& stream)
+    {
+        if (_internal::is_colorized(stream))
+        {
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+            char command[20];
+            std::snprintf(command, sizeof(command), "\033[38;2;%d;%d;%dm", r, g, b);
+            stream << command;
+        #elif defined(TERMCOLOR_OS_WINDOWS)
+        #endif
+        }
+        return stream;
+    }
+
+    template <uint8_t r, uint8_t g, uint8_t b> inline
+    std::ostream& on_color(std::ostream& stream)
+    {
+        if (_internal::is_colorized(stream))
+        {
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+            char command[20];
+            std::snprintf(command, sizeof(command), "\033[48;2;%d;%d;%dm", r, g, b);
+            stream << command;
+        #elif defined(TERMCOLOR_OS_WINDOWS)
+        #endif
+        }
+        return stream;
+    }
+
+    inline
+    std::ostream& grey(std::ostream& stream)
+    {
+        if (_internal::is_colorized(stream))
+        {
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
             stream << "\033[30m";
-#elif defined(TERMCOLOR_OS_WINDOWS)
+        #elif defined(TERMCOLOR_OS_WINDOWS)
             _internal::win_change_attributes(stream,
                 0   // grey (black)
             );
-#endif
+        #endif
         }
         return stream;
-}
+    }
 
-inline std::ostream &red(std::ostream &stream) {
+    inline
-  if (_internal::is_colorized(stream)) {
+    std::ostream& red(std::ostream& stream)
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+    {
+        if (_internal::is_colorized(stream))
+        {
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
             stream << "\033[31m";
-#elif defined(TERMCOLOR_OS_WINDOWS)
+        #elif defined(TERMCOLOR_OS_WINDOWS)
-    _internal::win_change_attributes(stream, FOREGROUND_RED);
+            _internal::win_change_attributes(stream,
-#endif
+                FOREGROUND_RED
+            );
+        #endif
         }
         return stream;
-}
+    }
 
-inline std::ostream &green(std::ostream &stream) {
+    inline
-  if (_internal::is_colorized(stream)) {
+    std::ostream& green(std::ostream& stream)
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+    {
+        if (_internal::is_colorized(stream))
+        {
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
             stream << "\033[32m";
-#elif defined(TERMCOLOR_OS_WINDOWS)
+        #elif defined(TERMCOLOR_OS_WINDOWS)
-    _internal::win_change_attributes(stream, FOREGROUND_GREEN);
+            _internal::win_change_attributes(stream,
-#endif
+                FOREGROUND_GREEN
+            );
+        #endif
         }
         return stream;
-}
+    }
 
-inline std::ostream &yellow(std::ostream &stream) {
+    inline
-  if (_internal::is_colorized(stream)) {
+    std::ostream& yellow(std::ostream& stream)
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+    {
+        if (_internal::is_colorized(stream))
+        {
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
             stream << "\033[33m";
-#elif defined(TERMCOLOR_OS_WINDOWS)
+        #elif defined(TERMCOLOR_OS_WINDOWS)
-    _internal::win_change_attributes(stream, FOREGROUND_GREEN | FOREGROUND_RED);
+            _internal::win_change_attributes(stream,
-#endif
+                FOREGROUND_GREEN | FOREGROUND_RED
+            );
+        #endif
         }
         return stream;
-}
+    }
 
-inline std::ostream &blue(std::ostream &stream) {
+    inline
-  if (_internal::is_colorized(stream)) {
+    std::ostream& blue(std::ostream& stream)
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+    {
+        if (_internal::is_colorized(stream))
+        {
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
             stream << "\033[34m";
-#elif defined(TERMCOLOR_OS_WINDOWS)
+        #elif defined(TERMCOLOR_OS_WINDOWS)
-    _internal::win_change_attributes(stream, FOREGROUND_BLUE);
+            _internal::win_change_attributes(stream,
-#endif
+                FOREGROUND_BLUE
+            );
+        #endif
         }
         return stream;
-}
+    }
 
-inline std::ostream &magenta(std::ostream &stream) {
+    inline
-  if (_internal::is_colorized(stream)) {
+    std::ostream& magenta(std::ostream& stream)
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+    {
+        if (_internal::is_colorized(stream))
+        {
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
             stream << "\033[35m";
-#elif defined(TERMCOLOR_OS_WINDOWS)
+        #elif defined(TERMCOLOR_OS_WINDOWS)
-    _internal::win_change_attributes(stream, FOREGROUND_BLUE | FOREGROUND_RED);
+            _internal::win_change_attributes(stream,
-#endif
+                FOREGROUND_BLUE | FOREGROUND_RED
+            );
+        #endif
         }
         return stream;
-}
+    }
 
-inline std::ostream &cyan(std::ostream &stream) {
+    inline
-  if (_internal::is_colorized(stream)) {
+    std::ostream& cyan(std::ostream& stream)
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+    {
+        if (_internal::is_colorized(stream))
+        {
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
             stream << "\033[36m";
-#elif defined(TERMCOLOR_OS_WINDOWS)
+        #elif defined(TERMCOLOR_OS_WINDOWS)
-    _internal::win_change_attributes(stream, FOREGROUND_BLUE | FOREGROUND_GREEN);
+            _internal::win_change_attributes(stream,
-#endif
+                FOREGROUND_BLUE | FOREGROUND_GREEN
+            );
+        #endif
         }
         return stream;
-}
+    }
 
-inline std::ostream &white(std::ostream &stream) {
+    inline
-  if (_internal::is_colorized(stream)) {
+    std::ostream& white(std::ostream& stream)
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+    {
+        if (_internal::is_colorized(stream))
+        {
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
             stream << "\033[37m";
-#elif defined(TERMCOLOR_OS_WINDOWS)
+        #elif defined(TERMCOLOR_OS_WINDOWS)
-    _internal::win_change_attributes(stream, FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED);
+            _internal::win_change_attributes(stream,
-#endif
+                FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED
+            );
+        #endif
         }
         return stream;
-}
+    }
 
-inline std::ostream &on_grey(std::ostream &stream) {
+
-  if (_internal::is_colorized(stream)) {
+
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+    inline
+    std::ostream& on_grey(std::ostream& stream)
+    {
+        if (_internal::is_colorized(stream))
+        {
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
             stream << "\033[40m";
-#elif defined(TERMCOLOR_OS_WINDOWS)
+        #elif defined(TERMCOLOR_OS_WINDOWS)
             _internal::win_change_attributes(stream, -1,
                 0   // grey (black)
             );
-#endif
+        #endif
         }
         return stream;
-}
+    }
 
-inline std::ostream &on_red(std::ostream &stream) {
+    inline
-  if (_internal::is_colorized(stream)) {
+    std::ostream& on_red(std::ostream& stream)
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+    {
+        if (_internal::is_colorized(stream))
+        {
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
             stream << "\033[41m";
-#elif defined(TERMCOLOR_OS_WINDOWS)
+        #elif defined(TERMCOLOR_OS_WINDOWS)
-    _internal::win_change_attributes(stream, -1, BACKGROUND_RED);
-#endif
-  }
-  return stream;
-}
-
-inline std::ostream &on_green(std::ostream &stream) {
-  if (_internal::is_colorized(stream)) {
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
-    stream << "\033[42m";
-#elif defined(TERMCOLOR_OS_WINDOWS)
-    _internal::win_change_attributes(stream, -1, BACKGROUND_GREEN);
-#endif
-  }
-  return stream;
-}
-
-inline std::ostream &on_yellow(std::ostream &stream) {
-  if (_internal::is_colorized(stream)) {
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
-    stream << "\033[43m";
-#elif defined(TERMCOLOR_OS_WINDOWS)
-    _internal::win_change_attributes(stream, -1, BACKGROUND_GREEN | BACKGROUND_RED);
-#endif
-  }
-  return stream;
-}
-
-inline std::ostream &on_blue(std::ostream &stream) {
-  if (_internal::is_colorized(stream)) {
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
-    stream << "\033[44m";
-#elif defined(TERMCOLOR_OS_WINDOWS)
-    _internal::win_change_attributes(stream, -1, BACKGROUND_BLUE);
-#endif
-  }
-  return stream;
-}
-
-inline std::ostream &on_magenta(std::ostream &stream) {
-  if (_internal::is_colorized(stream)) {
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
-    stream << "\033[45m";
-#elif defined(TERMCOLOR_OS_WINDOWS)
-    _internal::win_change_attributes(stream, -1, BACKGROUND_BLUE | BACKGROUND_RED);
-#endif
-  }
-  return stream;
-}
-
-inline std::ostream &on_cyan(std::ostream &stream) {
-  if (_internal::is_colorized(stream)) {
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
-    stream << "\033[46m";
-#elif defined(TERMCOLOR_OS_WINDOWS)
-    _internal::win_change_attributes(stream, -1, BACKGROUND_GREEN | BACKGROUND_BLUE);
-#endif
-  }
-  return stream;
-}
-
-inline std::ostream &on_white(std::ostream &stream) {
-  if (_internal::is_colorized(stream)) {
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
-    stream << "\033[47m";
-#elif defined(TERMCOLOR_OS_WINDOWS)
             _internal::win_change_attributes(stream, -1,
-                                     BACKGROUND_GREEN | BACKGROUND_BLUE | BACKGROUND_RED);
+                BACKGROUND_RED
-#endif
+            );
+        #endif
+        }
+        return stream;
+    }
+
+    inline
+    std::ostream& on_green(std::ostream& stream)
+    {
+        if (_internal::is_colorized(stream))
+        {
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+            stream << "\033[42m";
+        #elif defined(TERMCOLOR_OS_WINDOWS)
+            _internal::win_change_attributes(stream, -1,
+                BACKGROUND_GREEN
+            );
+        #endif
+        }
+        return stream;
+    }
+
+    inline
+    std::ostream& on_yellow(std::ostream& stream)
+    {
+        if (_internal::is_colorized(stream))
+        {
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+            stream << "\033[43m";
+        #elif defined(TERMCOLOR_OS_WINDOWS)
+            _internal::win_change_attributes(stream, -1,
+                BACKGROUND_GREEN | BACKGROUND_RED
+            );
+        #endif
+        }
+        return stream;
+    }
+
+    inline
+    std::ostream& on_blue(std::ostream& stream)
+    {
+        if (_internal::is_colorized(stream))
+        {
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+            stream << "\033[44m";
+        #elif defined(TERMCOLOR_OS_WINDOWS)
+            _internal::win_change_attributes(stream, -1,
+                BACKGROUND_BLUE
+            );
+        #endif
+        }
+        return stream;
+    }
+
+    inline
+    std::ostream& on_magenta(std::ostream& stream)
+    {
+        if (_internal::is_colorized(stream))
+        {
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+            stream << "\033[45m";
+        #elif defined(TERMCOLOR_OS_WINDOWS)
+            _internal::win_change_attributes(stream, -1,
+                BACKGROUND_BLUE | BACKGROUND_RED
+            );
+        #endif
+        }
+        return stream;
+    }
+
+    inline
+    std::ostream& on_cyan(std::ostream& stream)
+    {
+        if (_internal::is_colorized(stream))
+        {
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+            stream << "\033[46m";
+        #elif defined(TERMCOLOR_OS_WINDOWS)
+            _internal::win_change_attributes(stream, -1,
+                BACKGROUND_GREEN | BACKGROUND_BLUE
+            );
+        #endif
+        }
+        return stream;
+    }
+
+    inline
+    std::ostream& on_white(std::ostream& stream)
+    {
+        if (_internal::is_colorized(stream))
+        {
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+            stream << "\033[47m";
+        #elif defined(TERMCOLOR_OS_WINDOWS)
+            _internal::win_change_attributes(stream, -1,
+                BACKGROUND_GREEN | BACKGROUND_BLUE | BACKGROUND_RED
+            );
+        #endif
         }
 
         return stream;
-}
+    }
 
-//! Since C++ hasn't a way to hide something in the header from
+
-//! the outer access, I have to introduce this namespace which
+
-//! is used for internal purpose and should't be access from
+    //! Since C++ hasn't a way to hide something in the header from
-//! the user code.
+    //! the outer access, I have to introduce this namespace which
-namespace _internal {
+    //! is used for internal purpose and should't be access from
-//! Since C++ hasn't a true way to extract stream handler
+    //! the user code.
-//! from the a given `std::ostream` object, I have to write
+    namespace _internal
-//! this kind of hack.
+    {
-inline FILE *get_standard_stream(const std::ostream &stream) {
+        //! Since C++ hasn't a true way to extract stream handler
+        //! from the a given `std::ostream` object, I have to write
+        //! this kind of hack.
+        inline
+        FILE* get_standard_stream(const std::ostream& stream)
+        {
             if (&stream == &std::cout)
                 return stdout;
             else if ((&stream == &std::cerr) || (&stream == &std::clog))
                 return stderr;
 
-  return 0;
+            return nullptr;
-}
+        }
 
-// Say whether a given stream should be colorized or not. It's always
+        // Say whether a given stream should be colorized or not. It's always
-// true for ATTY streams and may be true for streams marked with
+        // true for ATTY streams and may be true for streams marked with
-// colorize flag.
+        // colorize flag.
-inline bool is_colorized(std::ostream &stream) {
+        inline
+        bool is_colorized(std::ostream& stream)
+        {
             return is_atty(stream) || static_cast<bool>(stream.iword(colorize_index));
-}
+        }
 
-//! Test whether a given `std::ostream` object refers to
+        //! Test whether a given `std::ostream` object refers to
-//! a terminal.
+        //! a terminal.
-inline bool is_atty(const std::ostream &stream) {
+        inline
-  FILE *std_stream = get_standard_stream(stream);
+        bool is_atty(const std::ostream& stream)
+        {
+            FILE* std_stream = get_standard_stream(stream);
 
             // Unfortunately, fileno() ends with segmentation fault
             // if invalid file descriptor is passed. So we need to
@@ -379,17 +558,18 @@ inline bool is_atty(const std::ostream &stream) {
             if (!std_stream)
                 return false;
 
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
             return ::isatty(fileno(std_stream));
-#elif defined(TERMCOLOR_OS_WINDOWS)
+        #elif defined(TERMCOLOR_OS_WINDOWS)
             return ::_isatty(_fileno(std_stream));
-#endif
+        #endif
-}
+        }
 
-#if defined(TERMCOLOR_OS_WINDOWS)
+    #if defined(TERMCOLOR_OS_WINDOWS)
-//! Change Windows Terminal colors attribute. If some
+        //! Change Windows Terminal colors attribute. If some
-//! parameter is `-1` then attribute won't changed.
+        //! parameter is `-1` then attribute won't changed.
-inline void win_change_attributes(std::ostream &stream, int foreground, int background) {
+        inline void win_change_attributes(std::ostream& stream, int foreground, int background)
+        {
             // yeah, i know.. it's ugly, it's windows.
             static WORD defaultAttributes = 0;
 
@@ -408,7 +588,8 @@ inline void win_change_attributes(std::ostream &stream, int foreground, int back
                 hTerminal = GetStdHandle(STD_ERROR_HANDLE);
 
             // save default terminal attributes if it unsaved
-  if (!defaultAttributes) {
+            if (!defaultAttributes)
+            {
                 CONSOLE_SCREEN_BUFFER_INFO info;
                 if (!GetConsoleScreenBufferInfo(hTerminal, &info))
                     return;
@@ -416,7 +597,8 @@ inline void win_change_attributes(std::ostream &stream, int foreground, int back
             }
 
             // restore all default settings
-  if (foreground == -1 && background == -1) {
+            if (foreground == -1 && background == -1)
+            {
                 SetConsoleTextAttribute(hTerminal, defaultAttributes);
                 return;
             }
@@ -426,24 +608,27 @@ inline void win_change_attributes(std::ostream &stream, int foreground, int back
             if (!GetConsoleScreenBufferInfo(hTerminal, &info))
                 return;
 
-  if (foreground != -1) {
+            if (foreground != -1)
+            {
                 info.wAttributes &= ~(info.wAttributes & 0x0F);
                 info.wAttributes |= static_cast<WORD>(foreground);
             }
 
-  if (background != -1) {
+            if (background != -1)
+            {
                 info.wAttributes &= ~(info.wAttributes & 0xF0);
                 info.wAttributes |= static_cast<WORD>(background);
             }
 
             SetConsoleTextAttribute(hTerminal, info.wAttributes);
-}
+        }
-#endif // TERMCOLOR_OS_WINDOWS
+    #endif // TERMCOLOR_OS_WINDOWS
 
-} // namespace _internal
+    } // namespace _internal
 
 } // namespace termcolor
 
+
 #undef TERMCOLOR_OS_WINDOWS
 #undef TERMCOLOR_OS_MACOS
 #undef TERMCOLOR_OS_LINUX