formatting.hxx

Go to the documentation of this file.

#pragma once
 
// C++
#include <iomanip>
#include <functional>
#include <ostream>
#include <string>
#include <sstream>
#include <type_traits>
 
// cosmos
#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>
 
namespace cosmos {
        template <typename NUM>
        struct FormattedNumber;
}
 
inline std::ostream& operator<<(std::ostream &o, const cosmos::ProcessID &pid) {
        // 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;
}
 
inline std::ostream& operator<<(std::ostream &o, const cosmos::ThreadID &tid) {
        // similarly we could use special annotation here
        o << cosmos::to_integral(tid);
        return o;
}
 
inline std::ostream& operator<<(std::ostream &o, const cosmos::UserID &uid) {
        // similarly we could use special annotation here
        o << cosmos::to_integral(uid);
        return o;
}
 
inline std::ostream& operator<<(std::ostream &o, const cosmos::GroupID &gid) {
        // similarly we could use special annotation here
        o << cosmos::to_integral(gid);
        return o;
}
 
inline std::ostream& operator<<(std::ostream &o, const cosmos::SignalNr &sig) {
        // similarly we could use special annotation here
        o << cosmos::to_integral(sig);
        return o;
}
 
inline std::ostream& operator<<(std::ostream &o, const cosmos::FileNum &fd) {
        // similarly we could use special annotation here
        o << cosmos::to_integral(fd);
        return o;
}
 
// this is implemented outlined with explicit template instantiations for the
// currently necessary primitive types
template <typename NUM>
std::ostream& operator<<(std::ostream& o, const cosmos::FormattedNumber<NUM> &fmtnum);
 
 
namespace cosmos {
 
template <typename NUM>
struct FormattedNumber {
protected: // types
 
        using SetBaseFN = std::function<void(std::ostream&)>;
 
protected: // functions
 
        FormattedNumber(const NUM num, size_t width, SetBaseFN fn, std::string base_prefix) :
                m_num{num}, m_width{width}, m_setbase_fn{fn}, m_base_prefix{base_prefix} {}
 
public: // functions
 
        const FormattedNumber& showBase(bool yes_no) { m_show_base = yes_no; return *this; }
 
        size_t width() const { return m_width; }
        bool showBase() const { return m_show_base; }
        auto num() const { return m_num; }
        const std::string& basePrefix() const { return m_base_prefix; }
        SetBaseFN baseFN() const { return m_setbase_fn; }
 
        explicit operator std::string() const {
                std::stringstream ss;
                ss << *this;
                return ss.str();
        }
 
protected: // data
 
        NUM m_num;
        size_t m_width = 0;
        SetBaseFN m_setbase_fn;
        std::string m_base_prefix;
        bool m_show_base = true;
};
 
 
template <typename NUM>
struct HexNum :
                public FormattedNumber<NUM> {
        HexNum(const NUM num, size_t width) :
                FormattedNumber<NUM>{num, width, [](std::ostream &o){ o << std::hex; }, "0x"}
        {}
};
 
 
template <typename NUM>
struct OctNum :
                public FormattedNumber<NUM> {
        OctNum(const NUM num, size_t width) :
                FormattedNumber<NUM>{num, width, [](std::ostream &o){ o << std::oct; }, "0o"}
        {}
};
 
 
template <typename T>
auto to_printable_integer(T num) -> decltype(+num) {
        // using the unary + operator promotes the number to a printable type
        return +num;
}
 
 
COSMOS_API std::string sprintf(const char *fmt, ...) COSMOS_FORMAT_PRINTF(1, 2);
 
} // end ns cosmos