andreacasalino / coloredstream

c++ stringstream handling colors

This small package is intended to allow printing colored text into C++ console applications.

Before doing anything else, leave a star to this project ;).

What you would see from the console using this package:

It is cross-platform and all the functionalities are contained in ColoredStream.h.

The ability to show a colored text is made possible by building and printing a ColoredText object. ColoredText extends std::stringstream adding the possibility to show colored text. Such ability is enabled when passing a ColoredText instance to a std::cout or a std::cerr for printing something into the console. On the opposite, when passing a ColoredText instance to another kind of output stream, like for instance a std::ofstream, the object behaves like a normal std::stringstream, printing normal text.

Three possible color prescriptions can be specified:

• specify classical colors like red or yellow
• specify a 8-bit color code
• specify a R,G,B triplet

It is also possible to apply a specific background color:

The kind of color used for specifying the text (R,G,B triplet, 8-bit code, etc...) can be different from the one used for the background.

EXAMPLES

Still haven't left a star? Do it now!! ;).

Using this package is straightforward: you just need to create a ColoredText object and then pass it to std::cout (or std::cerr) for printing it. Suppose for example you want to display a red colored 'hello world', all you need to do would be this:

#include <ColoredStream/ColoredStream.h>
using namespace colored_stream;

std::cout << ColoredText{ClassicColor::RED, "Hello world"} << std::endl;

and that's it!

You may also want to create an empty ColoredText instance, whose content is created step by step, before printing it:

ColoredText colored_content(ClassicColor::RED);
colored_content << "Hello ";
colored_content << "World ";
colored_content << " :-)";

std::cout << colored_content << std::endl;

... or, you can pass a variadic number of inputs in order to build the object in place:

std::cout << ColoredText{ClassicColor::BLUE, "Hello ", "World ", " :-)"}
            << std::endl;

You can also prescribe the background color and not only the text one:

ColoredText stream{
    Settings{}.text(ClassicColor::RED).background(Uint8Color{11}),
    "Hello World"};
std::cout << stream << std::endl;

You can also decide to bind a certain color to a certain concrete std::ostream so that everything that will be passed to that stream will be rendered with a certain color. Indeed, you can use ColoredStream for this:

ColoredStream stream{ClassicColor::MAGENTA, std::cerr};
stream << "All this line was "
        << "passed to the same "
        << " ColoredStream";

stream << " ... also this from another line of code" << std::endl;

The created stream will be a wrapper of the concrete passed one. Every time something is passed to the wrapper, the prescription about the text and the background color is added and then the content is actually propagated to the concrete stream.

Check the samples folder for other examples.

CMAKE SUPPORT

You can fetch this package and link to the ColoredStream library, which will expose the position of ColoredStream.h:

include(FetchContent)
FetchContent_Declare(
colored_stream
GIT_REPOSITORY https://github.com/andreacasalino/ColoredStream.git
GIT_TAG        main
)
FetchContent_MakeAvailable(colored_stream)

and then link to the ColoredStream library:

target_link_libraries(${TARGET_NAME}
    ColoredStream
)

coloredstream's Issues

std::out Interoperable ability

### This is a Feature Request!

Ok so this isn't a real issue, because I ended up making something that serves my purpose, but I thought I would still put in the request here, as its the main reason I used this library, and I am sure for others they will want the same thing from this library.

What I am asking for is the ability for this to work exactly the same way that std::cout does, but with predefined colors. What I mean is that you can plug in various variables and such and just keep chaining if you want, without having to define the color on every text block.

/// something like this would be awesome

colored_stream::Print << "this prints yellow" << "this is yellow too"
<< someVar << " even shows up yellow" << std::endl;

I have already made something for myself FROM this library, and it took me awhile to get it working, so I guess I don't absolutely need it, but I still think that this will really attract more users to this AWESOME library you have made here.

Anyways if you don't want to add this feature, its ok, but I wanted to at least say thank you for making this library public!

Here is a picture of what I made using your library that works the way I am requesting :D