log.h

Go to the documentation of this file.

// Copyright 2021-2025 The Aerospace Corporation.
// This file is a part of SatCat5, licensed under CERN-OHL-W v2 or later.
 
#pragma once
 
#include <satcat5/list.h>
#include <satcat5/types.h>
 
// Default parameters:
#ifndef SATCAT5_LOG_MAXLEN      // Maximum string length per message
#define SATCAT5_LOG_MAXLEN  255
#endif
 
#ifndef SATCAT5_LOG_CONCISE     // Enable concise syntax?
#define SATCAT5_LOG_CONCISE 1
#endif
 
#ifndef SATCAT5_WELCOME_EMOJI   // UTF-8 string: [satellite] [smiling cat] [five o'clock]
#define SATCAT5_WELCOME_EMOJI "\xf0\x9f\x9b\xb0\xef\xb8\x8f\xf0\x9f\x90\xb1\xf0\x9f\x95\x94"
#endif
 
namespace satcat5 {
    namespace log {
        class EventHandler {
        public:
            virtual void log_event(s8 priority, unsigned nbytes, const char* msg) = 0;
        protected:
            EventHandler();
            ~EventHandler() SATCAT5_OPTIONAL_DTOR;
        private:
            friend satcat5::util::ListCore;
            satcat5::log::EventHandler* m_next;
        };
 
        class ToWriteable final : public satcat5::log::EventHandler {
        public:
            explicit ToWriteable(satcat5::io::Writeable* dst);
 
            void log_event(s8 priority, unsigned nbytes, const char* msg) override;
 
        private:
            satcat5::io::Writeable* const m_dst;
        };
 
        constexpr s8 DEBUG      = -20;
        constexpr s8 INFO       = -10;
        constexpr s8 WARNING    =   0;
        constexpr s8 ERROR      = +10;
        constexpr s8 CRITICAL   = +20;
 
        const char* priority_label(s8 priority);
 
        class LogBuffer final {
        public:
            LogBuffer() : m_wridx(0) {}
 
            const char* c_str();
 
            void wr_fix(const char* str, unsigned len);
            void wr_str(const char* str);
            void wr_h32(u32 val, unsigned nhex = 8);
            void wr_h64(u64 val, unsigned nhex = 16);
            void wr_d32(u32 val, unsigned zpad = 0);
            void wr_d64(u64 val, unsigned zpad = 0);
            void wr_s32(s32 val, unsigned zpad = 0);
            void wr_s64(s64 val, unsigned zpad = 0);
            inline void wr_dec(u32 val) {wr_d32(val);}
            inline void wr_hex(u32 val) {wr_h32(val);}
 
            unsigned len() const {return m_wridx;}
 
        private:
            friend satcat5::log::Log;
 
            // Forbid use of copy constructor.
            LogBuffer(const LogBuffer&) = delete;
            LogBuffer& operator=(const LogBuffer&) = delete;
 
            // Null-terminate the working buffer.
            inline void terminate() {m_buff[m_wridx] = 0;}
 
            // Internal buffer.
            unsigned m_wridx;
            char m_buff[SATCAT5_LOG_MAXLEN+1];
        };
 
        class Log final {
        public:
            explicit Log(s8 priority);
            Log(s8 priority, const char* str);
            Log(s8 priority, const char* str1, const char* str2);
            Log(s8 priority, const void* str, unsigned nbytes);
 
            ~Log();
 
            Log& write(const char* str);
            Log& write(bool val);
            Log& write(u8 val);
            Log& write(u16 val);
            Log& write(u32 val);
            Log& write(u64 val);
            Log& write(satcat5::io::Readable* rd);
            Log& write(const u8* val, unsigned nbytes);
            Log& write(const satcat5::eth::MacAddr& mac);
            Log& write(const satcat5::ip::Addr& ip);
 
            Log& write10(s32 val);  // Signed (e.g., "+1234" or "-1234")
            Log& write10(s64 val);
            Log& write10(u32 val);  // Unsigned (e.g., "1234")
            Log& write10(u64 val);
            inline Log& write10(s8  val)    {return write10(s32(val));}
            inline Log& write10(s16 val)    {return write10(s32(val));}
            inline Log& write10(u8  val)    {return write10(u32(val));}
            inline Log& write10(u16 val)    {return write10(u32(val));}
 
            template <class T> inline Log& write_obj(const T& obj)
                {obj.log_to(m_buff); return *this;}
 
        private:
            // Forbid use of copy constructor.
            Log(const Log&) = delete;
            Log& operator=(const Log&) = delete;
 
            const s8 m_priority;
            satcat5::log::LogBuffer m_buff;
        };
 
        bool pre_test_reset();
    }
}
 
// Enable concise syntax?
// This requires adding a few objects to the top-level namespace.
#if SATCAT5_LOG_CONCISE
    using satcat5::log::Log;
    constexpr s8 LOG_DEBUG      = satcat5::log::DEBUG;
    constexpr s8 LOG_INFO       = satcat5::log::INFO;
    constexpr s8 LOG_WARNING    = satcat5::log::WARNING;
    constexpr s8 LOG_ERROR      = satcat5::log::ERROR;
    constexpr s8 LOG_CRITICAL   = satcat5::log::CRITICAL;
#endif