io_readable.h

Go to the documentation of this file.

// Copyright 2023-2025 The Aerospace Corporation.
// This file is a part of SatCat5, licensed under CERN-OHL-W v2 or later.
 
#pragma once
 
#include <satcat5/polling.h>
#include <satcat5/types.h>
 
namespace satcat5 {
    namespace io {
        enum class CopyMode {
            STREAM,
            PACKET,
            ALWAYS,
        };
 
        class EventListener {
        public:
            virtual void data_rcvd(satcat5::io::Readable* src) = 0;
 
            virtual void data_unlink(satcat5::io::Readable* src) {}
 
        protected:
            ~EventListener() {}
        };
 
        class Readable : public satcat5::poll::OnDemand {
        public:
            virtual void set_callback(satcat5::io::EventListener* callback);
 
            virtual unsigned get_read_ready() const = 0;
 
            // Read various data types in big-endian format.
            u8 read_u8();
            // Triggers Doxygen warnings about missing docs, can we suppress?
            u16 read_u16();
            u32 read_u24();
            u32 read_u32();
            u64 read_u48();
            u64 read_u64();
            s8 read_s8();
            s16 read_s16();
            s32 read_s24();
            s32 read_s32();
            s64 read_s48();
            s64 read_s64();
            float read_f32();
            double read_f64();
 
            // Read various data types in little-endian format.
            u16 read_u16l();
            u32 read_u24l();
            u32 read_u32l();
            u64 read_u48l();
            u64 read_u64l();
            s16 read_s16l();
            s32 read_s24l();
            s32 read_s32l();
            s64 read_s48l();
            s64 read_s64l();
            float read_f32l();
            double read_f64l();
 
            virtual bool read_bytes(unsigned nbytes, void* dst);
 
            virtual bool read_consume(unsigned nbytes);
 
            unsigned read_str(unsigned dst_size, char* dst);
 
            virtual void read_finalize();
 
            template <class T> inline bool read_obj(T& t)
                {return t.read_from(this);}
 
            unsigned copy_to(satcat5::io::Writeable* dst);
 
            bool copy_and_finalize(
                satcat5::io::Writeable* dst,
                satcat5::io::CopyMode mode = CopyMode::PACKET);
 
        protected:
            friend satcat5::io::LimitedRead;
            friend satcat5::io::ReadableRedirect;
 
            explicit constexpr Readable(satcat5::io::EventListener* callback = 0)
                : m_callback(callback) {}
            ~Readable() SATCAT5_OPTIONAL_DTOR;
 
            virtual u8 read_next() = 0;
 
            void read_notify();
 
            virtual void read_underflow();
 
        private:
            void poll_demand();
 
            satcat5::io::EventListener* m_callback;
        };
 
        class ArrayRead : public satcat5::io::Readable {
        public:
            constexpr ArrayRead(const void* src, unsigned len)
                : m_src((const u8*)src), m_len(len), m_rdidx(0) {}
            constexpr ArrayRead(unsigned len, const void* src)
                : m_src((const u8*)src), m_len(len), m_rdidx(0) {}
 
            constexpr ArrayRead()
                : m_src(nullptr), m_len(0), m_rdidx(0) {}
 
            // Implement the public Readable API.
            unsigned get_read_ready() const override;
            void read_finalize() override;
 
            const u8* buffer() const
                { return m_src; }
 
            void read_reset(unsigned len);
 
        private:
            // Implement the private Readable API.
            u8 read_next() override;
            const u8* const m_src;
 
            // Internal state.
            unsigned m_len;     // Length of the backing array
            unsigned m_rdidx;   // Current read position
        };
 
        class LimitedRead : public satcat5::io::Readable {
        public:
            constexpr LimitedRead(satcat5::io::Readable* src, unsigned maxrd)
                : m_src(src), m_rem(maxrd) {}
            constexpr LimitedRead(unsigned maxrd, satcat5::io::Readable* src)
                : m_src(src), m_rem(maxrd) {}
 
            explicit LimitedRead(satcat5::io::Readable* src);
 
            // Implement the public Readable API.
            unsigned get_read_ready() const override;
            bool read_bytes(unsigned nbytes, void* dst) override;
            bool read_consume(unsigned nbytes) override;
            void read_finalize() override;
 
        protected:
            // Implement the private Readable API.
            u8 read_next() override;
 
            inline void read_reset(unsigned rem) {m_rem = rem;}
 
        private:
            satcat5::io::Readable* const m_src;
            unsigned m_rem;
        };
 
        class ReadableRedirect : public satcat5::io::Readable {
        public:
            // Implement the public Readable API.
            void set_callback(satcat5::io::EventListener* callback) override;
            unsigned get_read_ready() const override;
            bool read_bytes(unsigned nbytes, void* dst) override;
            bool read_consume(unsigned nbytes) override;
            void read_finalize() override;
 
        protected:
            explicit constexpr ReadableRedirect(satcat5::io::Readable* src)
                : m_src(src) {}
            ~ReadableRedirect() {}
 
            // Implement the private Readable API.
            u8 read_next() override;
            void read_underflow() override;
 
            inline void read_src(satcat5::io::Readable* src) {m_src = src;}
 
        private:
            satcat5::io::Readable* m_src;
        };
 
 
        class NullRead : public satcat5::io::Readable {
        public:
            NullRead() {}
            unsigned get_read_ready() const override;
        private:
            u8 read_next() override;
        };
 
        class NullSink : public satcat5::io::EventListener {
            void data_rcvd(satcat5::io::Readable* src) override;
        };
 
        extern satcat5::io::NullRead null_read;
        extern satcat5::io::NullSink null_sink;
    }
}