log.hxx

Go to the documentation of this file.

/*
 * Copyright (C) 2024-2026 David C. Manuelda (StormBytePP)
 *
 * This file is part of StormByte-Logger.
 *
 * StormByte-Logger original source is dual-licensed:
 *
 * 1. GNU Lesser General Public License v3.0 (or later)
 *    You may redistribute and/or modify this file under the terms of the
 *    GNU Lesser General Public License as published by the Free Software
 *    Foundation, either version 3 of the License, or (at your option)
 *    any later version.
 *
 * 2. Commercial license
 *    Alternatively, this file may be used under the terms of a commercial
 *    license agreement with the copyright holder
 *    (David C. Manuelda <StormByte@gmail.com>).
 *
 * Both licenses apply only to original StormByte-Logger source in this
 * repository. They do not cover other StormByte modules or any third-party
 * material shipped with this repository (including everything under
 * thirdparty/, and in particular the bundled StormByte-String tree and
 * the StormByte Base tree it vendors), which remains under its own license.
 *
 * Neither license grants any patent rights. Any patent licenses required
 * to use this software or third-party components must be obtained separately
 * from the patent holders.
 *
 * StormByte-Logger is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * version 3 along with StormByte-Logger. If not, see
 * <https://www.gnu.org/licenses/lgpl-3.0.html>.
 *
 * SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-StormByte-Commercial
 */
 
#pragma once
 
#include <StormByte/binary_data.hxx>
#include <StormByte/byte_size.hxx>
#include <StormByte/safe/clonable.hxx>
#include <StormByte/safe/cstring.hxx>
#include <StormByte/logger/manipulators.hxx>
#include <StormByte/logger/typedefs.hxx>
#include <StormByte/size.hxx>
#include <StormByte/safe/string.hxx>
#include <StormByte/safe/wcstring.hxx>
#include <StormByte/safe/wstring.hxx>
#include <StormByte/type_traits.hxx>
 
#include <cstddef>
#include <memory>
#include <ostream>
#include <span>
#include <string>
#include <string_view>
 
namespace StormByte::Logger {
    class Engine;
 
    inline void OStreamWrite(void* context, const char* data, std::size_t size) {
        if (context == nullptr || data == nullptr || size == 0)
            return;
        static_cast<std::ostream*>(context)->write(data, static_cast<std::streamsize>(size));
    }
 
    inline void OStreamManip(void* context, std::ostream& (*manip)(std::ostream&)) {
        if (context == nullptr || manip == nullptr)
            return;
        *static_cast<std::ostream*>(context) << manip;
    }
 
    class STORMBYTE_LOGGER_PUBLIC Log : protected StormByte::Safe::Clonable<Log> {
        friend STORMBYTE_LOGGER_PUBLIC Log& humanreadable_number(Log& log) noexcept;
        friend STORMBYTE_LOGGER_PUBLIC Log& humanreadable_bytes(Log& log) noexcept;
        friend STORMBYTE_LOGGER_PUBLIC Log& nohumanreadable(Log& log) noexcept;
        friend STORMBYTE_LOGGER_PUBLIC Log& noredact(Log& log) noexcept;
 
        public:
            using PointerType = StormByte::Safe::Clonable<Log>::PointerType;
 
            Log(std::ostream& out, const Level& level = Level::Info, std::string_view format = "[%L] %T")
                : Log(&OStreamWrite, &OStreamManip, &out, level, format) {}
 
            Log(const Log&) = default;
 
            Log(Log&&) noexcept = default;
 
            ~Log() noexcept override;
 
            Log& operator=(const Log&);
 
            Log& operator=(Log&&) noexcept;
 
            PointerType Scope(std::string_view path);
 
            bool Enabled(const Level& level) const noexcept;
 
            virtual Log& Color(const Level& level, const StormByte::Logger::Color& color);
 
            virtual StormByte::Logger::Color Color(const Level& level) const;
 
            virtual Log& Color(std::string_view component, const Level& level, const StormByte::Logger::Color& color);
 
            virtual StormByte::Logger::Color Color(std::string_view component, const Level& level) const;
 
            virtual Log& Format(std::string_view format);
 
            virtual StormByte::Safe::String Format() const;
 
            virtual Log& Format(std::string_view component, std::string_view format);
 
            virtual StormByte::Safe::String Format(std::string_view component) const;
 
            virtual Log& Throttle(const ThrottleSpec& spec);
 
            virtual Log& NoThrottle(const ThrottleSpec& spec);
 
            virtual Log& Throttle(double rate, std::size_t burst);
 
            virtual Log& Throttle(double rate, std::size_t burst, ThrottlePolicy policy, std::size_t value, std::size_t period = 0);
 
            virtual Log& Throttle(const Level& level, double rate, std::size_t burst);
 
            virtual Log& Throttle(GroupManip group, double rate, std::size_t burst);
 
            virtual Log& Throttle(ComponentManip component, double rate, std::size_t burst);
 
            virtual Log& Throttle(ComponentManip component, const Level& level, GroupManip group, double rate, std::size_t burst, ThrottlePolicy policy = ThrottlePolicy::Drop, std::size_t value = 0, std::size_t period = 0);
 
            virtual Log& NoThrottle();
 
            virtual Log& NoThrottle(const Level& level);
 
            virtual Log& NoThrottle(GroupManip group);
 
            virtual Log& NoThrottle(ComponentManip component);
 
            virtual Log& NoThrottle(ComponentManip component, const Level& level, GroupManip group);
 
            virtual Log& FlushThrottle();
 
            virtual Log& FlushThrottle(const ThrottleSpec& spec);
 
 
            template <typename T>
            inline Log& operator<<(const T& v)
            requires (
                (StormByte::Type::Arithmetic<std::decay_t<T>> && !StormByte::Type::SameAs<std::decay_t<T>, wchar_t>)
                || StormByte::Type::SameAs<std::decay_t<T>, std::string_view>
                || StormByte::Type::SameAs<std::decay_t<T>, const char*>
                || StormByte::Type::SameAs<std::decay_t<T>, char*>
            ) {
                if (!WillWrite()) [[likely]]
                    return *this;
                if constexpr (StormByte::Type::SameAs<std::decay_t<T>, const char*> || StormByte::Type::SameAs<std::decay_t<T>, char*>)
                    WriteValue(static_cast<const char*>(v));
                else if constexpr (StormByte::Type::SameAs<std::decay_t<T>, std::string_view>)
                    WriteValue(v);
                else
                    WriteValue(static_cast<std::decay_t<T>>(v));
                return *this;
            }
 
            inline Log& operator<<(const std::string& v) {
                if (!WillWrite()) [[likely]]
                    return *this;
                WriteValue(std::string_view{v});
                return *this;
            }
 
            inline Log& operator<<(const StormByte::Safe::CString& v) {
                if (!WillWrite()) [[likely]]
                    return *this;
                WriteValue(static_cast<std::string_view>(v));
                return *this;
            }
 
            inline Log& operator<<(const StormByte::Safe::String& v) {
                if (!WillWrite()) [[likely]]
                    return *this;
                WriteValue(static_cast<std::string_view>(v));
                return *this;
            }
 
            inline Log& operator<<(std::wstring_view v) {
                if (!WillWrite()) [[likely]]
                    return *this;
                Write(v);
                return *this;
            }
 
            inline Log& operator<<(const wchar_t* v) {
                if (!WillWrite()) [[likely]]
                    return *this;
                Write(v);
                return *this;
            }
 
            inline Log& operator<<(const StormByte::Safe::WCString& v) {
                if (!WillWrite()) [[likely]]
                    return *this;
                Write(static_cast<std::wstring_view>(v));
                return *this;
            }
 
            inline Log& operator<<(const StormByte::Safe::WString& v) {
                if (!WillWrite()) [[likely]]
                    return *this;
                Write(static_cast<std::wstring_view>(v));
                return *this;
            }
 
            inline Log& operator<<(std::span<const std::byte> v) {
                if (!WillWrite()) [[likely]]
                    return *this;
                Write(v);
                return *this;
            }
 
            inline Log& operator<<(const StormByte::BinaryData& v) {
                if (!WillWrite()) [[likely]]
                    return *this;
                Write(static_cast<std::span<const std::byte>>(v));
                return *this;
            }
 
            inline Log& operator<<(const StormByte::Size& v) {
                if (!WillWrite()) [[likely]]
                    return *this;
                const std::string text = static_cast<std::string>(v);
                WriteValue(std::string_view{text});
                return *this;
            }
 
            inline Log& operator<<(const StormByte::ByteSize& v) {
                if (!WillWrite()) [[likely]]
                    return *this;
                const std::string text = static_cast<std::string>(v);
                WriteValue(std::string_view{text});
                return *this;
            }
 
            inline Log& operator<<(const Level& level) {
                Write(level);
                return *this;
            }
 
            inline Log& operator<<(std::ostream& (*manip)(std::ostream&)) {
                Write(manip);
                return *this;
            }
 
            inline Log& operator<<(Log& (*manip)(Log&) noexcept) {
                Write(manip);
                return *this;
            }
 
            inline Log& operator<<(RedactManip m) {
                Write(m);
                return *this;
            }
 
            inline Log& operator<<(HexManip m) {
                Write(m);
                return *this;
            }
 
            inline Log& operator<<(NoHexManip m) {
                Write(m);
                return *this;
            }
 
            inline Log& operator<<(ColorManip manip) {
                Write(manip);
                return *this;
            }
 
            inline Log& operator<<(NoColorManip manip) {
                Write(manip);
                return *this;
            }
 
            inline Log& operator<<(FormatManip manip) {
                Write(manip);
                return *this;
            }
 
            inline Log& operator<<(PopFormatManip manip) {
                Write(manip);
                return *this;
            }
 
            inline Log& operator<<(GroupManip manip) {
                Write(manip);
                return *this;
            }
 
            inline Log& operator<<(ComponentManip manip) {
                Write(manip);
                return *this;
            }
 
            inline Log& operator<<(PopComponentManip manip) {
                Write(manip);
                return *this;
            }
 
            inline Log& operator<<(ResetComponentManip manip) {
                Write(manip);
                return *this;
            }
 
 
        protected:
            Log(SinkWrite write, SinkManip manip, void* context, const Level& level, std::string_view format);
 
            std::shared_ptr<Engine> m_engine;           
            StormByte::Safe::String m_scope_path;           
 
            bool WillWrite() const noexcept;
 
            bool PrepareLine();
 
            bool HasOpenOutputLine() const noexcept;
 
            bool LineDecided() const noexcept;
 
            bool LineAdmitted() const noexcept;
 
            virtual bool BeginPayload();
 
            template <typename T>
            void WriteValue(const T& v);
 
            PointerType Clone() const override;
 
            PointerType Move() override;
 
            virtual void Write(std::wstring_view v);
 
            virtual void Write(const wchar_t* v);
 
            virtual void Write(std::span<const std::byte> v);
 
            virtual void Write(const Level& level);
 
            virtual void Write(std::ostream& (*manip)(std::ostream&));
 
            virtual void Write(Log& (*manip)(Log&) noexcept);
 
            virtual void Write(RedactManip m);
 
            virtual void Write(HexManip m);
 
            virtual void Write(NoHexManip m);
 
            virtual void Write(ColorManip manip);
 
            virtual void Write(NoColorManip manip);
 
            virtual void Write(FormatManip manip);
 
            virtual void Write(PopFormatManip manip);
 
            virtual void Write(GroupManip manip);
 
            virtual void Write(ComponentManip manip);
 
            virtual void Write(PopComponentManip manip);
 
            virtual void Write(ResetComponentManip manip);
    };
 
    extern template STORMBYTE_LOGGER_PUBLIC void Log::WriteValue<bool>(const bool& v);
    extern template STORMBYTE_LOGGER_PUBLIC void Log::WriteValue<char>(const char& v);
    extern template STORMBYTE_LOGGER_PUBLIC void Log::WriteValue<signed char>(const signed char& v);
    extern template STORMBYTE_LOGGER_PUBLIC void Log::WriteValue<unsigned char>(const unsigned char& v);
    extern template STORMBYTE_LOGGER_PUBLIC void Log::WriteValue<short>(const short& v);
    extern template STORMBYTE_LOGGER_PUBLIC void Log::WriteValue<unsigned short>(const unsigned short& v);
    extern template STORMBYTE_LOGGER_PUBLIC void Log::WriteValue<int>(const int& v);
    extern template STORMBYTE_LOGGER_PUBLIC void Log::WriteValue<unsigned int>(const unsigned int& v);
    extern template STORMBYTE_LOGGER_PUBLIC void Log::WriteValue<long>(const long& v);
    extern template STORMBYTE_LOGGER_PUBLIC void Log::WriteValue<unsigned long>(const unsigned long& v);
    extern template STORMBYTE_LOGGER_PUBLIC void Log::WriteValue<long long>(const long long& v);
    extern template STORMBYTE_LOGGER_PUBLIC void Log::WriteValue<unsigned long long>(const unsigned long long& v);
    extern template STORMBYTE_LOGGER_PUBLIC void Log::WriteValue<float>(const float& v);
    extern template STORMBYTE_LOGGER_PUBLIC void Log::WriteValue<double>(const double& v);
    extern template STORMBYTE_LOGGER_PUBLIC void Log::WriteValue<long double>(const long double& v);
    extern template STORMBYTE_LOGGER_PUBLIC void Log::WriteValue<std::string_view>(const std::string_view& v);
    extern template STORMBYTE_LOGGER_PUBLIC void Log::WriteValue<const char*>(const char* const& v);
 
    template<typename Ptr>
    concept LogPointer =
        StormByte::Type::NullablePointer<Ptr>
        && StormByte::Type::DerivedFrom<typename std::remove_cvref_t<Ptr>::element_type, Log>;
 
    template <typename Ptr, typename T>
    Ptr& operator<<(Ptr& logger, const T& value) noexcept
        requires LogPointer<Ptr> {
        if (logger)
            *logger << value;
        return logger;
    }
 
    template <typename Ptr>
    Ptr& operator<<(Ptr& logger, const Level& level) noexcept
        requires LogPointer<Ptr> {
        if (logger)
            *logger << level;
        return logger;
    }
 
    template <typename Ptr>
    Ptr& operator<<(Ptr& logger, std::ostream& (*manip)(std::ostream&)) noexcept
        requires LogPointer<Ptr> {
        if (logger)
            *logger << manip;
        return logger;
    }
}