formatting.hxx File Reference

#include <iomanip>
#include <functional>
#include <ostream>
#include <string>
#include <sstream>
#include <type_traits>
#include <cosmos/compiler.hxx>
#include <cosmos/dso_export.h>
#include <cosmos/fs/types.hxx>
#include <cosmos/proc/types.hxx>
#include <cosmos/string.hxx>
#include <cosmos/thread/thread.hxx>
#include <cosmos/types.hxx>
#include <cosmos/utils.hxx>

Go to the source code of this file.

Classes
struct	cosmos::FormattedNumber< NUM >
	Base class for HexNum and OctNum format output helpers. More...
struct	cosmos::HexNum< NUM >
	Helper to output a primitive integer as hexadecimal in the style of 0x1234. More...
struct	cosmos::OctNum< NUM >
	Helper to output a primitive integer as octal in the style of 0o123. More...

Functions
std::ostream &	operator<< (std::ostream &o, const cosmos::ProcessID &pid)
std::ostream &	operator<< (std::ostream &o, const cosmos::ThreadID &tid)
std::ostream &	operator<< (std::ostream &o, const cosmos::UserID &uid)
std::ostream &	operator<< (std::ostream &o, const cosmos::GroupID &gid)
std::ostream &	operator<< (std::ostream &o, const cosmos::SignalNr &sig)
std::ostream &	operator<< (std::ostream &o, const cosmos::FileNum &fd)
template<typename NUM >
std::ostream &	operator<< (std::ostream &o, const cosmos::FormattedNumber< NUM > &fmtnum)
template<typename T >
auto	cosmos::to_printable_integer (T num) -> decltype(+num)
	This helper makes sure that any integer is turned into a printable integer.
std::string	cosmos::sprintf (const char *fmt,...) COSMOS_FORMAT_PRINTF(1
	This is a C++ variant of the libc sprintf() function.

Detailed Description

C stdio and C++ iostream related helper types and functions. Also some output operators for cosmos primitive types.

Definition in file formatting.hxx.

Function Documentation

operator<<() [1/7]

std::ostream & operator<< ( std::ostream & o, const cosmos::FileNum & fd )

inline

Definition at line 64 of file formatting.hxx.

                                                                      {
        // similarly we could use special annotation here
        o << cosmos::to_integral(fd);
        return o;
}

operator<<() [2/7]

template<typename NUM >

std::ostream & operator<<	(	std::ostream &	o,
		const cosmos::FormattedNumber< NUM > &	fmtnum )

Definition at line 68 of file formatting.cxx.

                                                                                {
        const auto orig_flags = o.flags();
        const auto orig_fill = o.fill();
 
        static_assert(std::is_integral_v<NUM>, "template type needs to be an integral integer type");
 
        // don't handle this with std::showbase, it's behaving badly e.g. the
        // "0x" prefix counts towards the field with, also, the fill character
        // will be prepended to the "0x" prefix resulting in things like
        // "0000x64".
        if (fmtnum.showBase())
                o << fmtnum.basePrefix();
        o << std::setw(fmtnum.width());
        fmtnum.baseFN()(o);
        o << std::setfill('0') << cosmos::to_printable_integer(fmtnum.num());
 
        o.flags(orig_flags);
        o.fill(orig_fill);
        return o;
}

operator<<() [3/7]

std::ostream & operator<< ( std::ostream & o, const cosmos::GroupID & gid )

inline

Definition at line 52 of file formatting.hxx.

                                                                       {
        // similarly we could use special annotation here
        o << cosmos::to_integral(gid);
        return o;
}

operator<<() [4/7]

std::ostream & operator<< ( std::ostream & o, const cosmos::ProcessID & pid )

inline

Definition at line 33 of file formatting.hxx.

                                                                         {
        // we could also think about using a consistent annotation of process
        // ids in the output like @1234 or <pid: 1234> something like that.
        o << cosmos::to_integral(pid);
        return o;
}

operator<<() [5/7]

std::ostream & operator<< ( std::ostream & o, const cosmos::SignalNr & sig )

inline

Definition at line 58 of file formatting.hxx.

                                                                        {
        // similarly we could use special annotation here
        o << cosmos::to_integral(sig);
        return o;
}

operator<<() [6/7]

std::ostream & operator<< ( std::ostream & o, const cosmos::ThreadID & tid )

inline

Definition at line 40 of file formatting.hxx.

                                                                        {
        // similarly we could use special annotation here
        o << cosmos::to_integral(tid);
        return o;
}

operator<<() [7/7]

std::ostream & operator<< ( std::ostream & o, const cosmos::UserID & uid )

inline

Definition at line 46 of file formatting.hxx.

                                                                      {
        // similarly we could use special annotation here
        o << cosmos::to_integral(uid);
        return o;
}

sprintf()

COSMOS_API std::string cosmos::sprintf	(	const char *	fmt,
			... )

This is a C++ variant of the libc sprintf() function.

This function is taking care of the memory management details of sprintf() and returns the fully formatted string as a std::string object.

On error an empty string is returned.

Definition at line 57 of file formatting.cxx.

                                        {
        va_list varargs;
        va_start(varargs, fmt);
        const auto ret = sprintf_v(fmt, varargs);
        va_end(varargs);
        return ret;
}

to_printable_integer()

template<typename T >

auto cosmos::to_printable_integer

(

T

num

)

-> decltype(+num)

This helper makes sure that any integer is turned into a printable integer.

Attempting to output a char related type onto an ostream will print its symbolic value as opposed to its numerical representation. To avoid this effect this helper function can be used to return a representation of num that will be printed as a numerical value when output onto an ostream.

Definition at line 157 of file formatting.hxx.

                                                   {
        // using the unary + operator promotes the number to a printable type
        return +num;
}