StreamParam, C++ (vc++)

StreamParam

//Microsoft (R) C/C++ Optimizing Compiler Version 19.00.23506 for x64

#include <iostream>
#include <sstream>

namespace rang {

enum class stream { Auto = 0, Ansi = 1, Off = 2 };
    
        namespace rang_implementation {
            inline int internalStreamModeIndex()
            {
                static const int xindex = std::ios_base::xalloc();
                return xindex;
            }
        }
    
        template <typename CharT, typename Traits>
        inline void setStreamMode(std::basic_ostream<CharT, Traits> &os, stream mode)
        {
            using namespace rang_implementation;
            
            long &curVal = os.iword(internalStreamModeIndex());
            curVal = static_cast<long>(mode);
        }
    
        template <typename CharT, typename Traits>
        inline stream streamMode(std::basic_ostream<CharT, Traits> &os)
        {
            using namespace rang_implementation;
            // Default iword is 0, so it's means that default stream::Auto should be 0
            long curVal = os.iword(internalStreamModeIndex());
            return static_cast<stream>(curVal);
        }

template<typename CharT, typename Traits,typename Alloc>
        class basic_esqseq_string_holder 
        {
            typedef std::basic_string<CharT, Traits, Alloc> StringType;

StringType mEsqSeqString;
        public:
            explicit basic_esqseq_string_holder(const StringType& str)
            :mEsqSeqString(str)
            {}

inline StringType str()const{ return mEsqSeqString; }
        };
        
        template<typename CharT, typename Traits,typename Alloc>
        basic_esqseq_string_holder<CharT, Traits, Alloc>
            processAnsi(const std::basic_string<CharT, Traits, Alloc>& str)
        {
            return basic_esqseq_string_holder<CharT, Traits, Alloc>(str);
        }
}

// Example:
namespace rang {
        enum class fg {
        black   = 30,
        red     = 31,
        green   = 32,
        yellow  = 33,
        blue    = 34,
        magenta = 35,
        cyan    = 36,
        gray    = 37,
        reset   = 39
    };
    
    template <typename CharT, typename Traits>
    inline std::basic_ostream<CharT, Traits> &
    setColor(std::basic_ostream<CharT, Traits> &os, fg const value)
    {
        return os << "\033[" << static_cast<int>(value) << "m";
    }
}

template <typename CharT, typename Traits>
inline std::basic_ostream<CharT, Traits> &
operator<<(std::basic_ostream<CharT, Traits> &os, const rang::fg &value)
{
    using namespace rang;
    using namespace rang_implementation;
    
    if(streamMode(os) == stream::Off)
        return os;
    if(streamMode(os) == stream::Ansi)
        return setColor(os, value);

return os;
}

template<typename CharT, typename Traits, typename Alloc>
inline std::basic_ostream<CharT, Traits>&
operator<<(std::basic_ostream<CharT, Traits>& os,
       const rang::basic_esqseq_string_holder<CharT, Traits, Alloc>& strHolder)
{
    using namespace rang;
    using namespace rang_implementation;
    
    auto string = strHolder.str();
    
    // exit if Off color enabled
    
    // Output ansi if terminal/stream support it.
    // Parse if it does not and output rang commands to os
    
    return os << string;
}

std::string coloredAnsiString(const std::string& str)
{
    std::ostringstream oss;
    
    rang::setStreamMode(oss,rang::stream::Ansi);
    
    oss << rang::fg::red << str << rang::fg::reset;
    return oss.str();
}

int main()
{
    // Load Ansi Escape string from file or elsewhere:
    auto string = coloredAnsiString("Hello World!");
    
    std::cout << rang::processAnsi(string) << std::endl;
}


run \| edit \| history \| help	0