posix_utils.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/eth_switch.h>
#include <satcat5/io_buffer.h>
#include <satcat5/io_core.h>
#include <satcat5/log.h>
#include <satcat5/multi_buffer.h>
#include <satcat5/pkt_buffer.h>
#include <satcat5/timeref.h>
#include <list>
#include <string>
#include <vector>
 
#ifdef _WIN32
    #define SATCAT5_WIN32 1
#else
    #define SATCAT5_WIN32 0
#endif
 
namespace satcat5 {
    namespace util {
        class HeapAllocator {
        protected:
            explicit HeapAllocator(unsigned nbytes)
                : m_buffptr(new u8[nbytes]) {}
            ~HeapAllocator()
                { delete[] m_buffptr; }
 
            HeapAllocator(const HeapAllocator&) = delete;
            void operator=(const HeapAllocator&) = delete;
 
            u8* const m_buffptr;
        };
    }
 
    namespace eth {
        class SwitchCoreHeap final
            : public satcat5::util::HeapAllocator
            , public satcat5::eth::SwitchCore {
        public:
            explicit SwitchCoreHeap(unsigned nbytes = 65536);
        };
    }
 
    namespace io {
        std::string read_str(satcat5::io::Readable* src);
 
        class BufferedTee
            : public satcat5::util::HeapAllocator
            , public satcat5::io::ArrayWrite {
        public:
            explicit BufferedTee(unsigned nbytes = 4096);
 
            inline void add(satcat5::io::Writeable* dst)
                { m_list.push_back(dst); }
            inline void remove(satcat5::io::Writeable* dst)
                { m_list.remove(dst); }
 
            bool write_finalize() override;
 
        protected:
            std::list<satcat5::io::Writeable*> m_list;
        };
 
        class BufferedWriterHeap final
            : public satcat5::util::HeapAllocator
            , public satcat5::io::BufferedWriter {
        public:
            explicit BufferedWriterHeap(
                satcat5::io::Writeable* dst,
                unsigned nbytes = 4096);
        };
 
        class KeyboardStream : public satcat5::poll::Always {
        public:
            explicit KeyboardStream(
                satcat5::io::Writeable* dst,
                bool line_buffer = true);
            virtual ~KeyboardStream();
 
        protected:
            void poll_always() override;
            void write_key(int ch);
            satcat5::io::Writeable* const m_dst;
            const bool m_line_buffer;
        };
 
        class MultiBufferHeap
            : public satcat5::util::HeapAllocator
            , public satcat5::io::MultiBuffer {
        public:
            explicit MultiBufferHeap(unsigned nbytes=65536);
            virtual ~MultiBufferHeap() {}
        };
 
        class PacketBufferHeap final
            : public satcat5::util::HeapAllocator
            , public satcat5::io::PacketBuffer {
        public:
            explicit PacketBufferHeap(unsigned nbytes=4096);
        };
 
        class PacketBufferTee final
            : public satcat5::io::ReadableRedirect
            , public satcat5::io::BufferedTee {
        public:
            explicit PacketBufferTee(unsigned nbytes=4096);
            inline void clear() {m_buff.clear();}
        protected:
            satcat5::io::PacketBufferHeap m_buff;
        };
 
        class StreamBufferHeap final
            : public satcat5::util::HeapAllocator
            , public satcat5::io::PacketBuffer {
        public:
            explicit StreamBufferHeap(unsigned nbytes=4096);
        };
 
        class StreamBufferTee final
            : public satcat5::io::ReadableRedirect
            , public satcat5::io::BufferedTee {
        public:
            explicit StreamBufferTee(unsigned nbytes=4096);
            inline void clear() {m_buff.clear();}
        protected:
            satcat5::io::StreamBufferHeap m_buff;
        };
    }
 
    namespace util {
        class PosixTimer : public satcat5::util::TimeRef {
        public:
            PosixTimer();
            u32 raw() override;         // Monotonic millisecond counter
            s64 gps() const;            // Milliseconds since GPS epoch
        };
 
        class PosixTimekeeper {
        public:
            PosixTimekeeper();
            virtual ~PosixTimekeeper();
 
            inline s64 gps()        {return m_timer.gps();}
            inline TimeVal now()    {return m_timer.now();}
            inline u32 raw()        {return m_timer.raw();}
 
            satcat5::util::TimeRef* timer() {return &m_timer;}
 
        protected:
            satcat5::util::PosixTimer m_timer;
            satcat5::irq::VirtualTimer m_adapter;
        };
 
        void sleep_msec(unsigned msec);
 
        void service_msec(unsigned total_msec, unsigned msec_per_iter = 10);
    }
 
    namespace log {
        std::string format(const satcat5::eth::MacAddr& addr);
        std::string format(const satcat5::ip::Addr& addr);
 
        class ToConsole final : public satcat5::log::EventHandler {
        public:
            explicit ToConsole(s8 threshold=satcat5::log::DEBUG);
 
            void disable() {m_threshold = INT8_MAX;}
 
            void suppress(const char* msg);
 
            bool contains(const char* msg);
 
            void clear() {m_last_msg.clear();}
            bool empty() {return m_last_msg.empty();}
 
            // Publically accessible members:
            s8 m_threshold;             
            std::string m_last_msg;     
 
        protected:
            void log_event(s8 priority, unsigned nbytes, const char* msg) override;
            std::vector<std::string> m_suppress;
            satcat5::util::PosixTimer m_timer;
            satcat5::util::TimeVal m_tref;
        };
    }
}