io_writeable.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/types.h>
 
namespace satcat5 {
    namespace io {
        class Writeable {
        public:
            virtual unsigned get_write_space() const = 0;
 
            // Write various data types in big-endian format.
            void write_u8(u8 data);
            void write_u16(u16 data);
            void write_u24(u32 data);
            void write_u32(u32 data);
            void write_u48(u64 data);
            void write_u64(u64 data);
            void write_s8(s8 data);
            void write_s16(s16 data);
            void write_s24(s32 data);
            void write_s32(s32 data);
            void write_s48(s64 data);
            void write_s64(s64 data);
            void write_f32(float data);
            void write_f64(double data);
 
            // Write various data types in little-endian format.
            void write_u16l(u16 data);
            void write_u24l(u32 data);
            void write_u32l(u32 data);
            void write_u48l(u64 data);
            void write_u64l(u64 data);
            void write_s16l(s16 data);
            void write_s24l(s32 data);
            void write_s32l(s32 data);
            void write_s48l(s64 data);
            void write_s64l(s64 data);
            void write_f32l(float data);
            void write_f64l(double data);
 
            virtual void write_bytes(unsigned nbytes, const void* src);
 
            void write_str(const char* str);
 
            virtual bool write_finalize();
 
            virtual void write_abort();
 
            template <class T> inline void write_obj(const T& obj)
                {obj.write_to(this);}
 
        protected:
            friend LimitedWrite;
            friend WriteableBroadcast;
            friend WriteableRedirect;
 
            constexpr Writeable() {}
            ~Writeable() {}
 
            virtual void write_next(u8 data) = 0;
 
            virtual void write_overflow();
        };
 
        class ArrayWrite : public satcat5::io::Writeable {
        public:
            constexpr ArrayWrite(void* dst, unsigned len)
                : m_dst((u8*)dst), m_len(len), m_ovr(false), m_wridx(0), m_wrlen(0) {}
            constexpr ArrayWrite(unsigned len, void* dst)
                : m_dst((u8*)dst), m_len(len), m_ovr(false), m_wridx(0), m_wrlen(0) {}
 
            // Implement the public Readable API.
            unsigned get_write_space() const override;
            void write_abort() override;
            bool write_finalize() override;
            void write_overflow() override;
 
            const u8* buffer() const
                { return m_dst; }
 
            inline unsigned written_len() const
                { return m_wrlen; }
 
        private:
            // Implement the private Writeable API.
            void write_next(u8 data) override;
 
            // Internal state.
            u8* const       m_dst;
            const unsigned  m_len;
            bool            m_ovr;
            unsigned        m_wridx;
            unsigned        m_wrlen;
        };
 
        template <unsigned SIZE>
        class ArrayWriteStatic : public satcat5::io::ArrayWrite {
        public:
            constexpr ArrayWriteStatic()
                : ArrayWrite(m_buff, SIZE), m_buff{} {}
        private:
            u8 m_buff[SIZE];
        };
 
        class LimitedWrite : public satcat5::io::Writeable {
        public:
            constexpr LimitedWrite(satcat5::io::Writeable* dst, unsigned maxwr)
                : m_dst(dst), m_rem(maxwr) {}
            constexpr LimitedWrite(unsigned maxwr, satcat5::io::Writeable* dst)
                : m_dst(dst), m_rem(maxwr) {}
 
            unsigned get_write_space() const override;
            void write_bytes(unsigned nbytes, const void* src) override;
 
        protected:
            // Implement the private Writeable API.
            void write_next(u8 data) override;
 
        private:
            satcat5::io::Writeable* const m_dst;
            unsigned m_rem;
        };
 
        class WriteableRedirect : public satcat5::io::Writeable {
        public:
            unsigned get_write_space() const override;
            void write_abort() override;
            void write_bytes(unsigned nbytes, const void* src) override;
            bool write_finalize() override;
        protected:
            explicit constexpr WriteableRedirect(satcat5::io::Writeable* dst)
                : m_dst(dst) {}
            ~WriteableRedirect() {}
            void write_next(u8 data) override;
            void write_overflow() override;
            inline void write_dst(satcat5::io::Writeable* dst) {m_dst = dst;}
        private:
            satcat5::io::Writeable* m_dst;
        };
 
        class NullWrite : public satcat5::io::Writeable {
        public:
            explicit constexpr NullWrite(unsigned wspace)
                : m_write_space(wspace) {}
            unsigned get_write_space() const override;
            void write_bytes(unsigned nbytes, const void* src) override;
        private:
            void write_next(u8 data) override;
            const unsigned m_write_space;
        };
 
        extern satcat5::io::NullWrite null_write;
    }
}