fmt.hpp

Go to the documentation of this file.

#ifndef BSL_FMT_HPP
#define BSL_FMT_HPP

#include "details/fmt_impl_char_type.hpp"
#include "details/fmt_impl_cstr_type.hpp"
#include "details/fmt_impl_bool.hpp"
#include "details/fmt_impl_integral.hpp"
#include "details/fmt_impl_null_pointer.hpp"
#include "details/fmt_impl_void_pointer.hpp"

#include "details/out.hpp"

#include "cstdint.hpp"
#include "enable_if.hpp"
#include "forward.hpp"
#include "fmt_options.hpp"
#include "is_bool.hpp"
#include "is_integral.hpp"
#include "is_null_pointer.hpp"
#include "is_same.hpp"
#include "is_pointer.hpp"
#include "move.hpp"

namespace bsl
{
    template<typename V>
    class fmt final
    {
        fmt_options m_ops;
        V const &m_val;

    public:
        constexpr fmt(fmt_options const &ops, V const &val) noexcept    // --
            : m_ops{ops}, m_val{val}
        {}

        constexpr fmt(fmt_options const &ops, V const &val, bsl::uintmax width) noexcept
            : m_ops{ops}, m_val{val}
        {
            constexpr bsl::uintmax max_width{1000U};
            if (width > max_width) {
                width = max_width - 1U;
            }

            m_ops.set_width(width);
        }

        constexpr fmt(cstr_type const str, V const &val) noexcept    // --
            : fmt{fmt_options{str}, val}
        {}

        constexpr fmt(cstr_type const str, V const &val, bsl::uintmax const width) noexcept
            : fmt{fmt_options{str}, val, width}
        {}

        template<typename T, typename U>
        friend constexpr out<T>
        operator<<(out<T> const o, fmt<U> &&arg) noexcept;    // PRQA S 2107 // NOLINT
    };

    template<typename T, typename U>
    [[maybe_unused]] constexpr out<T>
    operator<<(out<T> const o, fmt<U> &&arg) noexcept
    {
        if constexpr (o.empty()) {
            return o;
        }

        fmt_impl(o, arg.m_ops, arg.m_val);    // NOLINT
        return o;
    }

    template<
        typename T,
        typename U,
        enable_if_t<!is_bool<U>::value, bool> = true,
        enable_if_t<!is_same<U, char_type>::value, bool> = true,
        enable_if_t<!is_pointer<U>::value, bool> = true,
        enable_if_t<!is_integral<U>::value, bool> = true,
        enable_if_t<!is_null_pointer<U>::value, bool> = true>
    [[maybe_unused]] constexpr out<T>
    operator<<(out<T> const o, U const &arg) noexcept
    {
        if constexpr (o.empty()) {
            return o;
        }

        fmt_impl(o, nullops, arg);    // NOLINT
        return o;
    }
}

#endif